--- /dev/null
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+# Usually these files are written by a python script from a template
+# before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# dotenv
+.env
+
+# virtualenv
+.venv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+# vim swap files
+*.swp
+
+# Python virtualenv
+virtualenv/
+
+# ansible retry files
+*.retry
--- /dev/null
+# Installation Process
+
+## Objective:
+Run a Grafana instance to provide a monitoring dashboard to a ceph
+cluster.
+
+## Pre-requisites
+### Monitoring host
+- docker and docker-compose (for simplicity)
+- grafana image (official latest 4.3 release from docker hub)
+- graphite image (docker.io/abezhenar/graphite-centos7)
+- clone the cephmetrics repo (docker configuration, dashboards)
+- host that will run the monitor should have passwordless ssh to all the ceph
+nodes
+- the storage for the graphite database should be on SSD/flash if possible
+- needs PyYAML, tested with python 2.7.13
+
+### Ceph Cluster Nodes
+- collectd rpm (5.7 or above)
+
+## Installation Sequence
+Install the monitoring endpoint first, and then apply the collectd configuration
+to each of the ceph nodes.
+
+
+## Setting Up the monitoring endpoint
+On the monitoring host, perform the following steps;
+1. Pull the required docker images (*listed above*)
+2. we need to persist the grafana configuration db and settings, as well as the
+graphite data.
+```markdown
+mkdir -p /opt/docker/grafana/etc
+mkdir -p /opt/docker/grafana/data/plugins
+mkdir -p /opt/docker/graphite
+```
+3. Download the additional status panel plugin
+```markdown
+cd /opt/docker/grafana/data/plugins
+wget https://grafana.com/api/plugins/vonage-status-panel/versions/1.0.4/download
+unzip download
+rm -f download
+```
+4. Copy the seed .ini file for grafana to the containers etc directory, and reset
+the permissions to be compatible with the containers
+```markdown
+cp etc/grafana/grafana.ini /opt/docker/grafana/etc
+chown -R 104:107 /opt/docker/grafana
+chown -R 997 /opt/docker/graphite
+chmod g+w /opt/docker/graphite
+
+```
+5. Edit the docker-compose.yml example (if necessary)
+6. From the directory with the compose file, issue
+```
+docker-compose up -d
+```
+7. check that the containers are running and the endpoints are listening
+7.1 Use ```docker ps```
+7.2 use ```netstat``` and look for the following ports: 3000,80,2003,2004,7002
+7.3 open a browser and connect to graphite - it should be running on port 80 of
+the local machine
+8. Add the graphite instance as a datasource to grafana
+8.1 update setup/add_datasource.json with the IP of the host machine
+8.2 register the graphite instance to grafana as the default data source
+```markdown
+curl -u admin:admin -H "Content-Type: application/json" -X POST http://localhost:3000/api/datasources \
+--data-binary @setup/add_datasource.json
+```
+9. Install the grafana labs pie-chart plugin
+9.1 open a shell session to the grafana instance, and install the plugin
+```markdown
+docker exec -it grafana bash
+grafana-cli plugins install grafana-piechart-panel
+```
+10. the sample dashboards need to be added/edited to reflect the ceph cluster to
+monitor
+10.1 seed dashboards are provided in the dashboards/current directory
+10.2 edit ```dashboard.yml``` with the shortnames of the OSD's and RGW's, plus
+the dns domain name of the environment.
+10.3 run the following command
+```markdown
+python dashUpdater.py
+```
+
+
+### Updating the dashboards
+After adding ceph nodes to the configuration, update the ```dashboard.yml```
+file, and then rerun the ```dashUpdater.py``` script.
+
+
+## Configuration on Each Ceph Node
+You may need to update your SELINUX policy to allow the write_graphite plugin
+to access outbound on port 2003. To test, simply disable SELINUX
+1. install collectd (this will also require libcollectdclient)
+2. create the required directories for the cephmetrics collectors (see known
+issues [2])
+```markdown
+mkdir -p /usr/lib64/collectd/python-plugins/collectors
+```
+3. copy the collectors to the directory created in [2], and cephmetrics.py
+to /usr/lib64/collectd/python-plugins
+4. Setup the collectd plugins
+4.1 Update the write_graphite.conf file to specify the hostname where the
+grafana/graphite environment is (use a hostname not IP - anecdotally I found that
+with an IP the plugin fails to connect to the graphite container port?)
+4.2 copy the example plugin files to the /etc/collectd.d directory (i.e. cpu.conf,
+memory.conf etc)
+5. update the "ClusterName" parameter in the cephmetrics plugin file to match
+ the name of your ceph cluster (default is 'ceph')
+6. copy the example collectd.conf file to the ceph node (or update the existing
+configuration to ensure there is a ```Include "/etc/collectd.d/*.conf"``` entry)
+7. enable collectd
+8. start collectd
+9. check collectd is running without errors
+
+## Known Issues
+1. Following a reboot of an OSD node, the cephmetrics collectd plugin doesn't send disk
+stats. ***Workaround**: Following the reboot of an OSD, restart the collectd service.*
+2. the cephmetrics.py and collectors should be installed through python-setuptools to cut down on
+the installation steps.
+3. SELINUX may block the write_graphite plugin writing outbound on port 2003
+
+
+
+
--- /dev/null
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+ This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+ 0. Additional Definitions.
+
+ As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+ "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+ An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+ A "Combined Work" is a work produced by combining or linking an
+Application with the Library. The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+ The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+ The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+ 1. Exception to Section 3 of the GNU GPL.
+
+ You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+ 2. Conveying Modified Versions.
+
+ If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+ a) under this License, provided that you make a good faith effort to
+ ensure that, in the event an Application does not supply the
+ function or data, the facility still operates, and performs
+ whatever part of its purpose remains meaningful, or
+
+ b) under the GNU GPL, with none of the additional permissions of
+ this License applicable to that copy.
+
+ 3. Object Code Incorporating Material from Library Header Files.
+
+ The object code form of an Application may incorporate material from
+a header file that is part of the Library. You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+ a) Give prominent notice with each copy of the object code that the
+ Library is used in it and that the Library and its use are
+ covered by this License.
+
+ b) Accompany the object code with a copy of the GNU GPL and this license
+ document.
+
+ 4. Combined Works.
+
+ You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+ a) Give prominent notice with each copy of the Combined Work that
+ the Library is used in it and that the Library and its use are
+ covered by this License.
+
+ b) Accompany the Combined Work with a copy of the GNU GPL and this license
+ document.
+
+ c) For a Combined Work that displays copyright notices during
+ execution, include the copyright notice for the Library among
+ these notices, as well as a reference directing the user to the
+ copies of the GNU GPL and this license document.
+
+ d) Do one of the following:
+
+ 0) Convey the Minimal Corresponding Source under the terms of this
+ License, and the Corresponding Application Code in a form
+ suitable for, and under terms that permit, the user to
+ recombine or relink the Application with a modified version of
+ the Linked Version to produce a modified Combined Work, in the
+ manner specified by section 6 of the GNU GPL for conveying
+ Corresponding Source.
+
+ 1) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (a) uses at run time
+ a copy of the Library already present on the user's computer
+ system, and (b) will operate properly with a modified version
+ of the Library that is interface-compatible with the Linked
+ Version.
+
+ e) Provide Installation Information, but only if you would otherwise
+ be required to provide such information under section 6 of the
+ GNU GPL, and only to the extent that such information is
+ necessary to install and execute a modified version of the
+ Combined Work produced by recombining or relinking the
+ Application with a modified version of the Linked Version. (If
+ you use option 4d0, the Installation Information must accompany
+ the Minimal Corresponding Source and Corresponding Application
+ Code. If you use option 4d1, you must provide the Installation
+ Information in the manner specified by section 6 of the GNU GPL
+ for conveying Corresponding Source.)
+
+ 5. Combined Libraries.
+
+ You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+ a) Accompany the combined library with a copy of the same work based
+ on the Library, uncombined with any other library facilities,
+ conveyed under the terms of this License.
+
+ b) Give prominent notice with the combined library that part of it
+ is a work based on the Library, and explaining where to find the
+ accompanying uncombined form of the same work.
+
+ 6. Revised Versions of the GNU Lesser General Public License.
+
+ The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+ If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
--- /dev/null
+On the ceph node install collectd
+- tested with collectd-5.7.0-4.el7ost.x86_64
+
+Interval is set to 10 in collectd.conf
+
+write_graphite plugin configured as follows;
+
+LoadPlugin "write_graphite"
+<Plugin write_graphite>
+ <Node "local">
+ Host "192.168.1.52"
+ Port "2003"
+ Protocol "tcp"
+ LogSendErrors true
+ Prefix "collectd."
+ StoreRates true
+ AlwaysAppendDS false
+ EscapeCharacter "_"
+ PreserveSeparator true
+ SeparateInstances true
+ </Node>
+</Plugin>
+
+5.7 introduces the PreserveSeparator parm, allowing the type instance name to
+contain '.'. At the moment I used .'s in the metric name since the same plugin
+provides all metrics.
+
+Comments welcome!
+
+This is what an entry looks like as seen in influx
+collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._rgw_root.num_bytes_recovered
+ | | \ \ \ \
+ | | \ \ \ \
+ | | | \ \ \
+prefix | hostname | plugin name | type |ceph|metric| metric name
+ name group
+
+In the case of pools, the metric name is prefixed by the pool name
+
+Added cephmetrics.conf to /etc/collectd.d dir
+
+mkdir -p /usr/lib64/collectd/python-plugins
+
+to the plugin dir, I copied
+ - cephmetrics.py
+ - collectors dir
+
+
+Known Issues
+1. Singlestat panels don't track the graph panel values 100% of the time
+
+
+
+
+Container Configuration - pulled from docker.io registry
+- grafana - grafana/grafana (official image)
+- graphite - nickstenning/graphite - https://hub.docker.com/r/nickstenning/graphite/
+
--- /dev/null
+# cephmetrics
+
+Cephmetrics is a tool that allows a user to visually monitor various metrics in a running Ceph cluster.
+
+## Prerequisites
+- RHEL 7 should be running on all hosts
+- A functional ceph cluster running version ceph-osd-10.2.7-27.el7cp.x86_64 or later is already up and running.
+- Another host machine independent of the ceph machines must be available. This host will be used to receive data pushed by the hosts in the Ceph cluster, and will run the dashboard to display that data.
+- A host machine on which to execute `ansible-playbook` to orchestrate the deployment must be available.
+- Passwordless SSH access from the deploy host to the ceph hosts. The username should be the same for all hosts.
+- Passwordless sudo access on the ceph and dashboard hosts
+- All hosts must share the same DNS domain
+
+## Resulting configuration
+
+After running this procedure, you will have the following configuration.
+- The ceph nodes will have `collectd` installed, along with collector plugins from `cephmetrics-collectd`
+- The dashboard host will have `grafana` installed and configured to display various dashboards by querying data received from Ceph nodes via a `graphite-web`, `python-carbon`, and `python-whisper` stack.
+
+## Installation
+
+### Install cephmetrics-ansible
+
+First, decide which machine you want to use to run `ansible-playbook`. If you used [`ceph-ansible`](https://github.com/ceph/ceph-ansible) to set up your cluster, you may want to reuse that same host to take advantage of the inventory file that was created as part of that process.
+
+Once the host is selected, perform the following steps there. This will install a repo which includes the cephmetrics installation code and ansible (version 2.2.3 or later):
+```
+sudo su -
+mkdir ~/cephmetrics
+subscription-manager repos --enable rhel-7-server-optional-rpms --enable rhel-7-server-rhscon-2-installer-rpms
+curl -L -o /etc/yum.repos.d/cephmetrics.repo http://download.ceph.com/cephmetrics/rpm-master/el7/cephmetrics.repo
+yum install cephmetrics-ansible
+```
+
+### Create or edit the inventory file
+
+Next, we need an inventory file. If you are running `ansible-playbook` on a host that previously ran `ceph-ansible`, you may simply modify `/etc/ansible/hosts`; otherwise you may copy `/usr/share/cephmetrics-ansible/inventory.sample` and modify it if you wish.
+
+The inventory file format looks like:
+
+ [ceph-grafana]
+ grafana_host.example.com
+
+ [osds]
+ osd0.example.com
+ osd1.example.com
+ osd2.example.com
+
+ [mons]
+ mon0.example.com
+ mon1.example.com
+ mon2.example.com
+
+ [mdss]
+ mds0.example.com
+
+ [rgws]
+ rgw0.example.com
+
+If you are running `ansible-playbook` on a host mentioned in the inventory file, you will need to append `ansible_connection=local` to each line in the inventory file that mentions that host. An example:
+ ```
+ my_host.example.com ansible_connection=local
+ ```
+Omit the mdss section if no ceph mds nodes are installed. Omit the rgws section if no rgw nodes are installed.
+
+Ansible variables can be set in a `vars.yml` file if necessary. If it is required, make sure to add `-e '@/path/to/vars.yml` to your `ansible-playbook` invocation below. [Click here](./ansible/README.md) for more information.
+
+## Deploy via ansible-playbook
+
+If you are using a `ceph-ansible` host, run these commands:
+```
+cd /usr/share/cephmetrics-ansible
+ansible-playbook -v playbook.yml
+```
+
+Otherwise, run these commands:
+```
+cd /usr/share/cephmetrics-ansible
+ansible-playbook -v -i /path/to/inventory playbook.yml
+```
+
+Note: The reason it is necessary to change directories is so that `ansible-playbook` will use the bundled `ansible.cfg`; there is currently no command-line argument allowing the specification of an arbitrary `.cfg` file.
--- /dev/null
+
+collectd
+- add network and cpu to all deployments
+- define standard easy roll-out conf (use collectd.d for write_graphite, cephmetrics, cpu and network)
+
+Dashboard
+
+
+collectd : cephmetrics
+- add metrics starting message so you know collection is active
+
+Python Modules
+Mon
+-
+
+RGW
+-
+
+
+
+Completed Items
+05/24 RGW: implement the latencies as different metrics to allow summarisation at the db layer
+05/24 MON: add ceph health status (OK/WARN) to output dict
+05/24 Dashboard: Add ceph health text
+05/29 OSD: OSD metrics added, with dashboard updates
\ No newline at end of file
--- /dev/null
+# Deploying cephmetrics with ansible
+
+This set of ansible roles, in combination with `playbook.yml`, provide a way to deploy cephmetrics to monitor a Ceph cluster.
+
+## Prerequisites
+- RHEL 7 is supported with `devel_mode` set to `True` or `False`. Ubuntu 16.04 and CentOS 7 are supported only when `devel_mode` is `True` at this point.
+- Currently only RHEL 7 is supported for all hosts
+- A functional [ceph](https://ceph.com/) cluster. [collectd](https://collectd.org/) will be used to collect metrics
+- A separate host to receive data pushed by hosts in the Ceph cluster, and run the dashboard to display that data.
+- An inventory file describing your cluster.
+- A host on which to execute `ansible-playbook` to orchestrate the deployment. This can be the same as the dashboard host.
+- Passwordless SSH access from the deploy host to the ceph hosts. The username should be the same for all hosts.
+- Passwordless sudo access on the ceph and dashboard hosts
+- All hosts must share the same DNS domain
+
+## Example inventory file
+
+ [ceph-grafana]
+ cephmetrics.example.com
+
+ [osds]
+ osd0.example.com
+ osd1.example.com
+ osd3.example.com
+
+ [mons]
+ mon0.example.com
+ mon1.example.com
+ mon2.example.com
+
+ [mdss]
+ mds0.example.com
+
+ [rgws]
+ rgw0.example.com
+
+Notes:
+- Omit any sections from the inventory file for which your cluster has no hosts.
+- If you are running `ansible-playbook` directly on the dashboard (`ceph-grafana`) host, its inventory entry should look like:
+ ```
+ [ceph-grafana]
+ cephmetrics.example.com ansible_connection=local
+ ```
+
+## Roles
+- [ceph-collectd](./roles/ceph-collectd/): Used for ceph cluster hosts
+- [ceph-grafana](./roles/ceph-grafana/): Used for the dashboard host
+
+## Variables
+You may override certain variables by creating a `vars.yml` file:
+- `ansible_ssh_user`: The user account use for SSH connections. This may also be set on a per-host basis in the inventory file.
+- `cluster`: The name of the Ceph cluster. Default: ceph
+- `firewalld_zone`: The `firewalld` zone to use when opening ports for Grafana and Carbon. Default: public
+- `devel_mode`: Whether to perform a development-mode deployment vs. a production deployment. Default: true
+- `whisper`: May be used to configure [whisper retention](http://graphite.readthedocs.io/en/latest/config-carbon.html#storage-schemas-conf) settings. Default:
+ ```
+ whisper:
+ retention:
+ - ['10s', '7d']
+ - ['1m', '30d']
+ - ['15m', '5y']
+ ```
+
+These variables are only relevent when `devel_mode` is true:
+- `use_epel`: Whether or not to use EPEL and grafana.com instead of ceph.com-sourced packages for dependencies. Default: false
+
+## Current Limitations
+
+- Currently, metrics are only *displayed* for `osd` and `rgw` hosts.
+- Authentication for grafana and graphite is fixed and creates a user `admin` with password `admin`.
+- Services are deployed on the dashboard host directly; there is not yet support for a containerized deployment.
+
+## Usage
+If you are not overriding any variables:
+```
+ ansible-playbook -v -i ./inventory
+```
+Or, if you are:
+```
+ ansible-playbook -v -i ./inventory -e '@vars.yml'
+```
--- /dev/null
+[defaults]
+roles_path: ./roles/
+host_key_checking: False
+forks: 50
--- /dev/null
+[cephmetrics]
+name=cephmetrics packages for \$basearch
+baseurl=https://chacra.ceph.com/r/cephmetrics/master/HEAD/rhel/7/flavors/default/\$basearch
+enabled=1
+gpgcheck=0
+type=rpm-md
+
+[cephmetrics-noarch]
+name=cephmetrics noarch packages
+baseurl=https://chacra.ceph.com/r/cephmetrics/master/HEAD/rhel/7/flavors/default/noarch
+enabled=1
+gpgcheck=0
+type=rpm-md
+
+[cephmetrics-source]
+name=cephmetrics source packages
+baseurl=https://chacra.ceph.com/r/cephmetrics/master/HEAD/rhel/7/flavors/default/SRPMS
+enabled=1
+gpgcheck=0
+type=rpm-md
--- /dev/null
+[cephmetrics]
+name=cephmetrics packages for \$basearch
+baseurl=http://download.ceph.com/cephmetrics/rpm-master/el7/\$basearch
+enabled=1
+gpgcheck=0
+type=rpm-md
+
+[cephmetrics-noarch]
+name=cephmetrics noarch packages
+baseurl=http://download.ceph.com/cephmetrics/rpm-master/el7/noarch
+enabled=1
+gpgcheck=0
+type=rpm-md
+
+[cephmetrics-source]
+name=cephmetrics source packages
+baseurl=http://download.ceph.com/cephmetrics/rpm-master/el7/SRPMS
+enabled=0
+gpgcheck=0
+type=rpm-md
--- /dev/null
+[ceph-grafana]
+grafana_host.example.com
+
+[osds]
+osd0.example.com
+osd1.example.com
+osd2.example.com
+
+[mons]
+mon0.example.com
+mon1.example.com
+mon2.example.com
+
+[mdss]
+mds0.example.com
+
+[rgws]
+rgw0.example.com
--- /dev/null
+---
+- hosts:
+ - ceph-grafana
+ become: true
+ roles:
+ - ceph-grafana
+
+- hosts:
+ # These are roles used by ceph-ansible
+ - mons
+ - agents
+ - osds
+ - mdss
+ - rgws
+ - nfss
+ - restapis
+ - rbdmirrors
+ - clients
+ - mgrs
+ # This role is (so far) only used for testing
+ - cluster
+ become: true
+ roles:
+ - ceph-collectd
+
+- hosts: localhost
+ connection: local
+ gather_facts: false
+ tasks:
+ - name: Print dashboard URL
+ debug:
+ msg: "All done! You may access your dashboard at http://{{ groups['ceph-grafana'][0] }}:3000/ with user 'admin' and password 'admin'."
--- /dev/null
+---
+- name: purge grafana host
+ hosts:
+ - ceph-grafana
+ become: true
+ tasks:
+ - name: Stop and disable services
+ service:
+ name: "{{ item }}"
+ enabled: no
+ state: stopped
+ with_items:
+ - grafana-server
+ - carbon-cache
+ - httpd
+ failed_when: false
+
+ - name: Remove packages
+ package:
+ name: "{{ item }}"
+ state: absent
+ with_items:
+ - graphite-web
+ - python-carbon
+ - grafana
+ - cephmetrics
+
+ - name: Remove files
+ file:
+ dest: "{{ item }}"
+ state: absent
+ with_items:
+ - /var/lib/graphite
+ - /var/lig/graphite-web
+ - /var/lib/grafana
+ - /var/lib/carbon
+ - /etc/grafana/grafana.ini
+ - /etc/carbon/storage-schemas.conf
+ - /etc/httpd/conf.d/graphite-web.conf
+ - /etc/yum.repos.d/cephmetrics.repo
+ - /etc/yum.repos.d/grafana.repo
+ - /tmp/dashboard.yml
+ - /tmp/dashUpdater.py
+ - /tmp/dashboards
+
+- name: purge collectd hosts
+ hosts:
+ # These are roles used by ceph-ansible
+ - mons
+ - agents
+ - osds
+ - mdss
+ - rgws
+ - nfss
+ - restapis
+ - rbdmirrors
+ - clients
+ - mgrs
+ # This role is (so far) only used for testing
+ - cluster
+ become: true
+ tasks:
+ - name: Stop and disable collectd
+ service:
+ name: collectd
+ enabled: no
+ state: stopped
+ failed_when: false
+
+ - name: Remove packages
+ package:
+ name: "{{ item }}"
+ state: absent
+ with_items:
+ - cephmetrics-collectors
+ - collectd
+
+ - name: Remove files
+ file:
+ dest: "{{ item }}"
+ state: absent
+ with_items:
+ - /etc/collectd.d/cephmetrics.conf
+ - /etc/collectd.d/cpu.conf
+ - /etc/collectd.d/memory.conf
+ - /etc/collectd.d/nics.conf
+ - /etc/collectd.d/write_graphite.conf
+ - /etc/collectd.conf
+ - /etc/yum.repos.d/cephmetrics.repo
+ - /usr/lib64/collectd
--- /dev/null
+---
+containerized_deployment: false
+cluster: ceph
+use_epel: false
+devel_mode: true
+collector_dependencies:
+ yum:
+ # For the json python module
+ - python-libs
+ # For the rados python module
+ - python-rados
+ # For the ceph_daemon python module
+ - ceph-common
+ # For semodule
+ - make
+ - libsemanage-python
+ - policycoreutils-python
+ - selinux-policy-devel
+ apt:
+ # For the json module, via libpython2.7-stdlib
+ - python2.7
+ # For the rados python module
+ - python-rados
+ # For the ceph_daemon python module
+ - ceph-common
--- /dev/null
+../../../common/files/cephmetrics-devel.repo
\ No newline at end of file
--- /dev/null
+../../../common/files/cephmetrics-prod.repo
\ No newline at end of file
--- /dev/null
+../../../../cephmetrics.py
\ No newline at end of file
--- /dev/null
+../../../../selinux/cephmetrics.te
\ No newline at end of file
--- /dev/null
+../../../../collectors
\ No newline at end of file
--- /dev/null
+../../../../etc
\ No newline at end of file
--- /dev/null
+---
+- name: Restart collectd
+ service:
+ name: collectd
+ enabled: yes
+ state: restarted
--- /dev/null
+---
+- name: Set collectd_conf
+ set_fact:
+ collectd_conf: "/etc/{{ 'collectd/' if ansible_pkg_mgr == 'apt' else '' }}collectd.conf"
+
+- name: Set collectd_conf_d
+ set_fact:
+ collectd_conf_d: "/etc/collectd{{ '/collectd.conf' if ansible_pkg_mgr == 'apt' else '' }}.d"
+
+- name: Ship collectd.conf
+ copy:
+ src: files/etc/collectd.conf
+ dest: "{{ collectd_conf }}"
+ notify: Restart collectd
+
+- name: Set PluginDir in collectd.conf
+ replace:
+ dest: "{{ collectd_conf }}"
+ regexp: 'PluginDir ".*"'
+ replace: 'PluginDir "{{ collectd_dir }}"'
+ notify: Restart collectd
+
+- name: Set Include path in collectd.conf
+ replace:
+ dest: "{{ collectd_conf }}"
+ regexp: 'Include ".*"'
+ replace: 'Include "{{ collectd_conf_d }}/*.conf"'
+ notify: Restart collectd
+
+- name: Ship /etc/collectd.d or /etc/collectd/collectd.conf.d
+ copy:
+ src: files/etc/collectd.d/
+ dest: "{{ collectd_conf_d }}"
+ notify: Restart collectd
+
+- name: Set hostname in write_graphite.conf
+ replace:
+ dest: "{{ collectd_conf_d }}/write_graphite.conf"
+ regexp: 'Host ".*"'
+ replace: "Host \"{{ groups['ceph-grafana'][0] }}\""
+ notify: Restart collectd
+
+- name: Set cluster name in cephmetrics.conf
+ replace:
+ dest: "{{ collectd_conf_d }}/cephmetrics.conf"
+ regexp: 'ClusterName ".*"'
+ replace: 'ClusterName "{{ cluster }}"'
+ notify: Restart collectd
+
+- name: Set ModulePath in cephmetrics.conf
+ replace:
+ dest: "{{ collectd_conf_d }}/cephmetrics.conf"
+ regexp: 'ModulePath ".*"'
+ replace: 'ModulePath "{{ collectd_cephmetrics_dir }}"'
+ notify: Restart collectd
--- /dev/null
+---
+- name: Set collectd_dir
+ set_fact:
+ collectd_dir: "/usr/lib{{ '64' if ansible_pkg_mgr == 'yum' else '' }}/collectd"
+
+- name: Set collectd_cephmetrics_dir
+ set_fact:
+ collectd_cephmetrics_dir: "{{ collectd_dir }}/cephmetrics"
+
+- name: Create collectors directory
+ file:
+ name: "{{ collectd_cephmetrics_dir }}/collectors"
+ state: directory
+
+- name: Ship collector plugins
+ copy:
+ src: files/collectors/
+ dest: "{{ collectd_cephmetrics_dir }}/collectors"
+ notify: Restart collectd
+
+- name: Ship cephmetrics.py
+ copy:
+ src: files/cephmetrics.py
+ dest: "{{ collectd_cephmetrics_dir }}"
+ notify: Restart collectd
--- /dev/null
+---
+- name: Install collectd
+ package:
+ name: collectd
+ state: latest
+ when:
+ - devel_mode
+ notify: Restart collectd
+
+- name: Install collectd-python
+ package:
+ name: collectd-python
+ state: latest
+ when:
+ - ansible_pkg_mgr == "yum"
+ - devel_mode
+ - not use_epel
+ notify: Restart collectd
+
+- name: Install cephmetrics-collectors
+ package:
+ name: cephmetrics-collectors
+ state: latest
+ when:
+ - ansible_pkg_mgr == "yum"
+ - not devel_mode
+ notify: Restart collectd
+
+- name: Install dependencies for collector plugins
+ package:
+ name: "{{ item }}"
+ state: latest
+ with_items: "{{ collector_dependencies[ansible_pkg_mgr] }}"
+ when:
+ - devel_mode
+ notify: Restart collectd
--- /dev/null
+---
+- include: setup_repos.yml
+ when:
+ - not containerized_deployment
+ tags:
+ - packages
+ - repos
+
+- include: install_packages.yml
+ when: not containerized_deployment
+ tags:
+ - packages
+
+- include: install_collectd_plugins.yml
+ when:
+ - not containerized_deployment
+ - devel_mode
+ tags:
+ - collectors
+
+- include: configure_collectd.yml
+ when: not containerized_deployment
+ tags:
+ - collectors
+
+- include: selinux.yml
+ when:
+ - not containerized_deployment
+ - ansible_pkg_mgr == "yum"
+ - ansible_selinux.status is defined
+ - ansible_selinux.status == 'enabled'
+ tags:
+ - selinux
+
+- include: start_collectd.yml
+ when: not containerized_deployment
+ tags:
+ - services
--- /dev/null
+---
+- name: Enable collectd_tcp_network_connect SELinux boolean
+ seboolean:
+ name: collectd_tcp_network_connect
+ state: yes
+ persistent: yes
+
+- name: Restore SELinux context of OSD journals
+ shell: "restorecon -R -v /var/lib/ceph/osd/*/journal"
+ when: "'osds' in group_names"
+ register: restorecon
+ changed_when: restorecon.stdout|length != 0 or restorecon.stderr|length != 0
+
+- include: selinux_module.yml
+ when:
+ - devel_mode
--- /dev/null
+---
+- name: Remove SELinux policy package
+ command: semodule -r cephmetrics
+ failed_when: false
+
+- name: Remove any SELinux-related files
+ file:
+ path: "{{ item }}"
+ state: absent
+ with_items:
+ - /tmp/cephmetrics.fc
+ - /tmp/cephmetrics.if
+ - /tmp/cephmetrics.pp
+ - /tmp/cephmetrics.te
+
+- name: Copy SELinux type enforcement file
+ copy:
+ src: cephmetrics.te
+ dest: /tmp/cephmetrics.te
+
+- name: Build SELinux policy package
+ command: make -f /usr/share/selinux/devel/Makefile cephmetrics.pp
+ args:
+ chdir: /tmp
+
+- name: Load SELinux policy package
+ command: semodule -i /tmp/cephmetrics.pp
+ notify: Restart collectd
--- /dev/null
+---
+- name: Enable EPEL
+ yum:
+ name: "https://dl.fedoraproject.org/pub/epel/epel-release-latest-{{ ansible_distribution_major_version }}.noarch.rpm"
+ state: "{{ 'present' if use_epel else 'absent' }}"
+ when:
+ - ansible_pkg_mgr == "yum"
+ - devel_mode
+
+- name: Add collectd repo
+ template:
+ src: collectd.list
+ dest: /etc/apt/sources.list.d/collectd.list
+ when:
+ - ansible_pkg_mgr == 'apt'
+ - devel_mode
+
+- name: Add collectd.org GPG key to apt
+ apt_key:
+ id: 3994D24FB8543576
+ state: present
+ keyserver: ha.pool.sks-keyservers.net
+ when:
+ - ansible_pkg_mgr == 'apt'
+ - devel_mode
+
+- name: Update apt cache
+ apt:
+ update_cache: true
+ when:
+ - ansible_pkg_mgr == 'apt'
+ - devel_mode
+
+- name: Install cephmetrics development repo
+ copy:
+ src: cephmetrics-devel.repo
+ dest: /etc/yum.repos.d/cephmetrics.repo
+ when:
+ - ansible_pkg_mgr == "yum"
+ - devel_mode
+
+- name: Remove cephmetrics development repo
+ file:
+ path: /etc/yum.repos.d/cephmetrics.repo
+ state: absent
+ when:
+ - ansible_pkg_mgr == "yum"
+ - use_epel
+ - devel_mode
+
+- name: Install cephmetrics production repo
+ copy:
+ src: files/cephmetrics-prod.repo
+ dest: /etc/yum.repos.d/cephmetrics.repo
+ when:
+ - ansible_pkg_mgr == "yum"
+ - not devel_mode
--- /dev/null
+---
+- name: Start collectd
+ service:
+ name: collectd
+ enabled: yes
+ state: started
--- /dev/null
+deb http://pkg.ci.collectd.org/deb {{ ansible_distribution_release }} collectd-5.7
--- /dev/null
+---
+defaults:
+ containerized_deployment: false
+ use_epel: false
+ devel_mode: true
+ replace_dashboards: true
+ grafana:
+ datasource: Local
+ # Note: changing this value won't update the password in Grafana itself;
+ # change it via the web UI and then override this value to reflect.
+ admin_password: admin
+ graphite:
+ service: "{{ 'graphite-web' if ansible_pkg_mgr == 'yum' else 'graphite-api' }}"
+ web_port: "{{ graphite_port | default('8080') }}"
+ api_port: 8888
+ user: admin
+ password: admin
+ # The unix account running the graphite-web process
+ unix_user:
+ yum: apache
+ apt: _graphite
+ carbon:
+ unix_user:
+ yum: carbon
+ apt: _graphite
+ storage_dir:
+ yum: /var/lib/carbon
+ apt: /var/lib/graphite
+ whisper:
+ retention:
+ - ['10s', '7d']
+ - ['1m', '30d']
+ - ['15m', '5y']
+ # The firewalld zone that carbon and grafana will use
+ firewalld_zone: public
+ # RHEL repos that need to be enabled with subscription-manager
+ rhsm_repos:
+ - rhel-7-server-rhscon-2-installer-rpms
+ - rhel-7-server-optional-rpms
+ devel_packages:
+ yum:
+ # unzip is needed to extract the Vonage plugin
+ - unzip
+ - graphite-web
+ - python-carbon
+ - grafana
+ # PyYAML is required by dashUpdater.py
+ - PyYAML
+ apt:
+ # unzip is needed to extract the Vonage plugin
+ - unzip
+ - graphite-api
+ # For graphite-api
+ - gunicorn3
+ - graphite-carbon
+ - grafana
+ # for dashUpdater.py
+ - python-yaml
+ - python-requests
--- /dev/null
+../../../common/files/cephmetrics-devel.repo
\ No newline at end of file
--- /dev/null
+../../../common/files/cephmetrics-prod.repo
\ No newline at end of file
--- /dev/null
+../../../../dashUpdater.py
\ No newline at end of file
--- /dev/null
+../../../../dashboards/current
\ No newline at end of file
--- /dev/null
+../../../../etc/grafana/grafana.ini
\ No newline at end of file
--- /dev/null
+deb https://packagecloud.io/grafana/stable/debian/ jessie main
--- /dev/null
+---
+- name: Restart Grafana
+ service:
+ name: grafana-server
+ state: restarted
+ enabled: true
+
+- name: Resize whisper databases
+ # xargs -P parallelizes execution; scale it to the number of cores on the system
+ shell: "find /var/lib/carbon/whisper -name '*.wsp' -print0 | xargs -n1 -0 -P {{ ansible_processor_vcpus }} -I {} whisper-resize {} {{ whisper_retention.replace(',', ' ') }}"
+ register: whisper_resize
+ failed_when: "'Traceback' in whisper_resize.stdout"
+ no_log: true
+
+- name: Restart graphite-web
+ service:
+ # graphite-web is served by httpd
+ name: httpd
+ state: restarted
+ enabled: true
+ when:
+ - "{{ graphite.service == 'graphite-web' }}"
+
+- name: Restart graphite-api
+ service:
+ name: graphite-api
+ state: restarted
+ enabled: true
+ when:
+ - "{{ graphite.service == 'graphite-api' }}"
+
+- name: Restart carbon-cache
+ service:
+ name: carbon-cache
+ state: restarted
+ enabled: true
--- /dev/null
+---
+- name: Set WHISPER_AUTOFLUSH to True
+ lineinfile:
+ dest: /etc/carbon/carbon.conf
+ regexp: "^WHISPER_AUTOFLUSH = .*"
+ insertafter: "^#.*buffering writes from the kernel.*"
+ line: "WHISPER_AUTOFLUSH = True"
+ notify:
+ - Restart carbon-cache
+
+- name: Fail when the the first whisper retention value is not 10s
+ fail:
+ msg: "The first whisper retention value must be '10s', not '{{ whisper.retention[0][0] }}' in order to match collectd's interval"
+ failed_when: whisper.retention[0][0] != '10s'
+ any_errors_fatal: true
+
+- name: Set whisper_retention
+ set_fact:
+ whisper_retention: "{{ whisper.retention|map('join', ':')|join(',') }}"
+
+- name: Configure retention for collectd stats
+ template:
+ src: storage-schemas.conf
+ dest: /etc/carbon/storage-schemas.conf
+ notify:
+ - Resize whisper databases
+ - Restart carbon-cache
+
+- name: Ensure carbon storage has the right ownership
+ file:
+ path: "{{ carbon.storage_dir[ansible_pkg_mgr] }}"
+ state: directory
+ owner: "{{ carbon.unix_user[ansible_pkg_mgr] }}"
+ group: "{{ carbon.unix_user[ansible_pkg_mgr] }}"
+ recurse: yes
+ notify:
+ - Restart carbon-cache
--- /dev/null
+---
+- name: Check firewalld status
+ shell: "systemctl show firewalld | grep UnitFileState"
+ register: firewalld_status
+ failed_when: false
+ changed_when: false
+
+- name: Open ports for Grafana and Carbon
+ firewalld:
+ port: "{{ item }}"
+ zone: "{{ firewalld_zone }}"
+ state: enabled
+ immediate: true
+ permanent: true
+ with_items:
+ - 3000/tcp
+ - 2003/tcp
+ when: "'enabled' in firewalld_status.stdout"
--- /dev/null
+---
+- name: Make sure grafana is down
+ service:
+ name: grafana-server
+ state: stopped
+
+- name: Wait for grafana to be stopped
+ wait_for:
+ port: 3000
+ state: stopped
+
+- name: Write grafana.ini
+ copy:
+ src: files/grafana.ini
+ dest: /etc/grafana/grafana.ini
+ owner: root
+ group: grafana
+ mode: 0640
+ tags: [ini]
+
+- name: Set domain in grafana.ini
+ lineinfile:
+ dest: /etc/grafana/grafana.ini
+ regexp: "^domain = .*"
+ insertafter: "^;domain = .*"
+ line: "domain = {{ ansible_fqdn }}"
+ tags: [ini]
+
+- name: Set admin_password in grafana.ini
+ lineinfile:
+ dest: /etc/grafana/grafana.ini
+ regexp: "^admin_password = .*"
+ insertafter: "^;admin_password = .*"
+ line: "admin_password = {{ grafana.admin_password }}"
+ no_log: true
+ tags: [ini]
+
+- include: grafana_plugins.yml
+ when: devel_mode
+
+- name: Enable and start grafana
+ service:
+ name: grafana-server
+ state: started
+ enabled: true
+
+- name: Wait for grafana to start
+ wait_for:
+ port: 3000
+
+- name: Set grafana_data_source
+ set_fact:
+ grafana_data_source: >
+ {
+ "name":"{{ grafana.datasource }}",
+ "type":"graphite",
+ "url":"http://localhost:{{ graphite.web_port if graphite.service == 'graphite-web' else graphite.api_port }}",
+ "access":"proxy",
+ "basicAuth":false,
+ "isDefault":true
+ }
+
+- name: Add data source
+ uri:
+ url: http://localhost:3000/api/datasources
+ method: POST
+ user: admin
+ password: "{{ grafana.admin_password }}"
+ force_basic_auth: yes
+ body_format: json
+ body: "{{ grafana_data_source }}"
+ # If we get a 409 Conflict, it means we're already set up. We'll update
+ # after this.
+ status_code: 200,409
+ register: grafana_data_source_result
+
+- name: Get datasource ID
+ uri:
+ url: "http://localhost:3000/api/datasources/id/{{ grafana.datasource }}"
+ method: GET
+ user: "{{ graphite.user }}"
+ password: "{{ grafana.admin_password }}"
+ force_basic_auth: yes
+ register: grafana_data_source_id
+ when: grafana_data_source_result is defined and grafana_data_source_result.status == 409
+
+- name: Update datasource
+ uri:
+ url: "http://localhost:3000/api/datasources/{{ grafana_data_source_id.json.id }}"
+ method: PUT
+ user: "{{ graphite.user }}"
+ password: "{{ grafana.admin_password }}"
+ force_basic_auth: yes
+ body_format: json
+ body: "{{ grafana_data_source }}"
+ status_code: 200
+ when: grafana_data_source_result is defined and grafana_data_source_result.status == 409
+
+- name: Ship dashboard templates
+ copy:
+ src: files/dashboards
+ dest: /tmp/
+ when: devel_mode
+
+- name: Ship dashUpdater.py
+ copy:
+ src: files/dashUpdater.py
+ dest: /tmp/dashUpdater.py
+ when: devel_mode
+
+- name: Write dashboard.yml
+ template:
+ src: dashboard.yml
+ dest: /tmp/dashboard.yml
+ mode: 0600
+
+- name: Set dashupdate_cmd and dashboard_dir
+ set_fact:
+ dashupdate_cmd: "python /tmp/dashUpdater.py"
+ dashboard_dir: "/tmp/dashboards"
+ when: devel_mode
+
+- name: Set dashupdate_cmd and dashboard_dir
+ set_fact:
+ dashupdate_cmd: "/usr/libexec/cephmetrics/dashUpdater.py"
+ dashboard_dir: "/usr/share/cephmetrics/dashboards"
+ when: not devel_mode
+
+- name: Set dashupdate_mode
+ set_fact:
+ dashupdate_mode: "{{ 'refresh' if replace_dashboards else 'update' }}"
+
+- name: Push dashboards to Grafana
+ command: "{{ dashupdate_cmd }} -m {{ dashupdate_mode }} -c /tmp/dashboard.yml -D {{ dashboard_dir }}"
--- /dev/null
+---
+- include: configure_graphite_web.yml
+ when:
+ - graphite.service == 'graphite-web'
+
+- include: configure_graphite_api.yml
+ when:
+ - graphite.service == 'graphite-api'
--- /dev/null
+---
+- name: Write graphite-api systemd files
+ template:
+ src: "{{ item }}"
+ dest: "/etc/systemd/system/{{ item }}"
+ with_items:
+ - graphite-api.socket
+ - graphite-api.service
+ notify: Restart graphite-api
--- /dev/null
+---
+- name: Create Graphite DB tables
+ command: /usr/bin/graphite-manage syncdb --noinput
+ become_user: "{{ graphite.unix_user[ansible_pkg_mgr] }}"
+
+- name: Build Graphite index
+ command: /usr/bin/graphite-build-index
+ become_user: "{{ graphite.unix_user[ansible_pkg_mgr] }}"
+
+- name: Set or unset port in main httpd config
+ lineinfile:
+ dest: /etc/httpd/conf/httpd.conf
+ regexp: "^Listen .*"
+ line: "Listen 80"
+ insertafter: "^#Listen .*"
+ state: "{{ 'present' if graphite.web_port == '80' else 'absent' }}"
+ notify: Restart graphite-web
+
+- name: Set port in graphite httpd config
+ lineinfile:
+ dest: /etc/httpd/conf.d/graphite-web.conf
+ regexp: "^Listen .*"
+ line: "Listen {{ graphite.web_port }}"
+ insertbefore: "^<VirtualHost .*"
+ notify: Restart graphite-web
+
+- name: Set VirtualHost port in graphite httpd config
+ replace:
+ dest: /etc/httpd/conf.d/graphite-web.conf
+ regexp: "^<VirtualHost \\*:.+>$"
+ replace: "<VirtualHost *:{{ graphite.web_port }}>"
+ notify: Restart graphite-web
+
+- name: Allow connecting to graphite without auth
+ lineinfile:
+ dest: /etc/httpd/conf.d/graphite-web.conf
+ line: " Require all granted"
+ insertafter: '<Directory "/usr/share/graphite/">'
+ state: present
+ notify: Restart graphite-web
--- /dev/null
+---
+- name: Create Grafana plugins directory
+ file:
+ name: /var/lib/grafana/plugins
+ state: directory
+
+- name: Set grafana_plugins
+ set_fact:
+ grafana_plugins: "['vonage-status-panel', 'grafana-piechart-panel']"
+
+- name: Install Grafana plugins
+ command: "grafana-cli plugins install {{ item }}"
+ with_items: "{{ grafana_plugins }}"
+
+- name: Update Grafana plugins
+ command: "grafana-cli plugins update {{ item }}"
+ with_items: "{{ grafana_plugins }}"
+
+- name: Update status-panel for readability within the 'light' theme
+ command: "sed -i.bak -e 's/green/rgb(1,167,1)/g' /var/lib/grafana/plugins/vonage-status-panel/dist/css/status_panel.css"
--- /dev/null
+---
+- name: Install packages
+ package:
+ name: "{{ item }}"
+ state: latest
+ with_items: "{{ devel_packages[ansible_pkg_mgr] }}"
+ when: devel_mode
+
+- name: Install cephmetrics
+ package:
+ name: cephmetrics
+ state: latest
+ when: not devel_mode
--- /dev/null
+---
+- include: merge_vars.yml
+ tags:
+ - always
+
+- include: setup_repos.yml
+ when:
+ - not containerized_deployment
+ tags:
+ - packages
+ - repos
+
+- include: install_packages.yml
+ when: not containerized_deployment
+ tags:
+ - packages
+
+- include: configure_firewall.yml
+ tags:
+ - firewall
+
+- include: configure_carbon.yml
+ when: not containerized_deployment
+ tags:
+ - carbon
+
+- include: configure_graphite.yml
+ when: not containerized_deployment
+ tags:
+ - graphite
+
+- include: configure_grafana.yml
+ when: not containerized_deployment
+ tags:
+ - grafana
+
+- name: Reload systemd
+ systemd:
+ daemon_reload: yes
+ # Even when just calling daemon-reload, ansible < 2.4 requires a name for this call
+ name: grafana-server
+ tags:
+ - packages
+ - services
+
+- include: start_services.yml
+ when: not containerized_deployment
+ tags:
+ - services
--- /dev/null
+---
+- name: Combine default settings and user-defined variables
+ set_fact: {"{{ item }}": "{% if vars[item] is not defined %}{{ defaults[item] }}{% endif %}{% if vars[item] is mapping %}{{ defaults[item]|combine(vars[item]|default({})) }}{% endif %}"}
+ with_items: "{{ defaults.keys() }}"
+ no_log: true
--- /dev/null
+---
+- name: Enable EPEL
+ yum:
+ name: "https://dl.fedoraproject.org/pub/epel/epel-release-latest-{{ ansible_distribution_major_version }}.noarch.rpm"
+ state: "{{ 'present' if use_epel else 'absent' }}"
+ when:
+ - ansible_pkg_mgr == "yum"
+ - devel_mode
+
+- name: Install cephmetrics development repo
+ copy:
+ src: files/cephmetrics-devel.repo
+ dest: /etc/yum.repos.d/cephmetrics.repo
+ when:
+ - ansible_pkg_mgr == "yum"
+ - not use_epel
+ - devel_mode
+
+- name: Remove cephmetrics repo
+ file:
+ path: /etc/yum.repos.d/cephmetrics.repo
+ state: absent
+ when:
+ - ansible_pkg_mgr == "yum"
+ - use_epel
+ - devel_mode
+
+- name: Add Grafana repo
+ template:
+ src: grafana.repo
+ dest: /etc/yum.repos.d/grafana.repo
+ when:
+ - ansible_pkg_mgr == 'yum'
+ - use_epel
+ - devel_mode
+
+- name: Remove Grafana repo
+ file:
+ path: /etc/yum.repos.d/grafana.repo
+ state: absent
+ when:
+ - ansible_pkg_mgr == "yum"
+ - not use_epel
+ - devel_mode
+
+- name: Install grafana repo
+ copy:
+ src: files/grafana.list
+ dest: /etc/apt/sources.list.d/grafana.list
+ when:
+ - ansible_pkg_mgr == "apt"
+ - devel_mode
+
+- name: Add packagecloud GPG key to apt
+ apt_key:
+ # This is the key used by the grafana repo
+ url: https://packagecloud.io/gpg.key
+ id: D59097AB
+ state: present
+ when:
+ - ansible_pkg_mgr == "apt"
+ - devel_mode
+
+- name: Update apt cache
+ apt:
+ update_cache: true
+ when:
+ - ansible_pkg_mgr == 'apt'
+ - devel_mode
+
+- name: Enable subscription-manager repos
+ command: "subscription-manager repos{% for repo in rhsm_repos %} --enable={{ repo }}{% endfor %}"
+ when:
+ - ansible_pkg_mgr == "yum"
+ - not devel_mode
+
+- name: Install cephmetrics production repo
+ copy:
+ src: files/cephmetrics-prod.repo
+ dest: /etc/yum.repos.d/cephmetrics.repo
+ when:
+ - ansible_pkg_mgr == "yum"
+ - not devel_mode
--- /dev/null
+---
+- name: Enable and start services
+ service:
+ name: "{{ item }}"
+ state: started
+ enabled: true
+ with_items:
+ - carbon-cache
+ # graphite-web is served by httpd
+ - "{{ 'httpd' if graphite.service == 'graphite-web' else graphite.service }}"
+ - grafana-server
--- /dev/null
+---
+osd_servers: [{% for fqdn in groups['osds'] | default([]) %}{{ fqdn.split('.')[0] }},{% endfor %}]
+rgw_servers: [{% for fqdn in groups['rgws'] | default([]) %}{{ fqdn.split('.')[0] }},{% endfor %}]
+domain: "{{ ansible_domain }}"
+_dashboards:
+ - alert-status
+ - ceph-at-a-glance
+ - ceph-backend-storage
+ - ceph-cluster
+ - ceph-osd-information
+ - ceph-pools
+ - ceph-rgw-workload
+ - disk-busy-by-server
+ - iops-by-server
+ - iscsi-overview
+ - latency-by-server
+ - network-usage-by-node
+ - osd-node-detail
+_credentials:
+ user: admin
+ password: {{ grafana.admin_password }}
+_grafana_port: 3000
+_home_dashboard: ceph-at-a-glance
+_alert_dashboard: alert-status
--- /dev/null
+[grafana]
+name=grafana
+baseurl=https://packagecloud.io/grafana/stable/el/{{ ansible_distribution_major_version }}/$basearch
+repo_gpgcheck=1
+enabled=1
+gpgcheck=1
+gpgkey=https://packagecloud.io/gpg.key https://grafanarel.s3.amazonaws.com/RPM-GPG-KEY-grafana
+sslverify=1
+sslcacert=/etc/pki/tls/certs/ca-bundle.crt
--- /dev/null
+[Unit]
+Description=Graphite-API service
+Requires=graphite-api.socket
+
+[Service]
+ExecStart=/usr/bin/gunicorn3 -w2 graphite_api.app:app
+Restart=on-failure
+User={{ graphite.unix_user[ansible_pkg_mgr] }}
+Group={{ graphite.unix_user[ansible_pkg_mgr] }}
+ExecReload=/bin/kill -s HUP $MAINPID
+ExecStop=/bin/kill -s TERM $MAINPID
+PrivateTmp=true
+
+[Install]
+WantedBy=multi-user.target
--- /dev/null
+[Unit]
+Description=graphite-api socket
+
+[Socket]
+ListenStream=/run/graphite-api.sock
+ListenStream=127.0.0.1:{{ graphite.api_port }}
+
+[Install]
+WantedBy=sockets.target
--- /dev/null
+# Schema definitions for Whisper files. Entries are scanned in order,
+# and first match wins. This file is scanned for changes every 60 seconds.
+#
+# [name]
+# pattern = regex
+# retentions = timePerPoint:timeToStore, timePerPoint:timeToStore, ...
+[collectd]
+pattern = ^collectd\.
+retentions = {{ whisper_retention }}
+
+# Carbon's internal metrics. This entry should match what is specified in
+# CARBON_METRIC_PREFIX and CARBON_METRIC_INTERVAL settings
+[carbon]
+pattern = ^carbon\.
+retentions = 60:90d
+
+[default_1min_for_1day]
+pattern = .*
+retentions = 60s:1d
--- /dev/null
+#!/usr/bin/env python
+
+import os
+import logging
+import collectd
+
+from collectors.mon import Mon
+from collectors.rgw import RGW
+from collectors.osd import OSDs
+from collectors.iscsi import ISCSIGateway
+from collectors.common import flatten_dict, get_hostname
+
+
+PLUGIN_NAME = 'cephmetrics'
+
+
+class Ceph(object):
+
+ roles = {
+ "mon": "Mon",
+ "rgw": "RGW",
+ "osd": "OSDs",
+ "iscsi": "ISCSIGateway"
+ }
+
+ def __init__(self):
+ self.cluster_name = None
+ self.event_url = None
+ self.host_name = get_hostname()
+
+ self.mon = None
+ self.rgw = None
+ self.osd = None
+ self.iscsi = None
+
+ def probe(self):
+ """
+ set up which collector(s) to use, based on what types of sockets we
+ find in /var/run/ceph
+ """
+
+ mon_socket = Mon.probe(self.cluster_name, 'mon')
+ if mon_socket:
+ self.mon = Mon(self, self.cluster_name,
+ admin_socket=mon_socket[0])
+
+ rgw_socket = RGW.probe(self.cluster_name, 'rgw')
+ if rgw_socket:
+ self.rgw = RGW(self, self.cluster_name,
+ admin_socket=rgw_socket[0])
+
+ osd_socket = OSDs.probe(self.cluster_name, 'osd')
+ if osd_socket:
+ self.osd = OSDs(self, self.cluster_name)
+
+ if ISCSIGateway.probe():
+ self.iscsi = ISCSIGateway(self, self.cluster_name)
+
+ def get_stats(self):
+
+ stats = {}
+
+ if self.mon:
+ stats['mon'] = self.mon.get_stats()
+
+ if self.rgw:
+ stats['rgw'] = self.rgw.get_stats()
+
+ if self.osd:
+ stats['osd'] = self.osd.get_stats()
+
+ if self.iscsi:
+ stats['iscsi'] = self.iscsi.get_stats()
+
+ return stats
+
+
+def write_stats(role_metrics, stats):
+
+ flat_stats = flatten_dict(stats, '.')
+
+ for key_name in flat_stats:
+ attr_name = key_name.split('.')[-1]
+
+ # TODO: this needs some more think time, since the key from the name
+ # is not the key of the all_metrics dict
+ if attr_name in role_metrics:
+ attr_type = role_metrics[attr_name][1] # gauge / derive etc
+ else:
+ # assign a default
+ attr_type = 'gauge'
+
+ attr_value = flat_stats[key_name]
+
+ val = collectd.Values(plugin=PLUGIN_NAME, type=attr_type)
+ instance_name = "{}.{}".format(CEPH.cluster_name,
+ key_name)
+ val.type_instance = instance_name
+ val.values = [attr_value]
+ val.dispatch()
+
+
+def configure_callback(conf):
+
+ valid_log_levels = ['debug', 'info']
+
+ global CEPH
+ module_parms = {node.key: node.values[0] for node in conf.children}
+
+ log_level = module_parms.get('LogLevel', 'debug')
+ if log_level not in valid_log_levels:
+ collectd.error("cephmetrics: LogLevel specified is invalid - must"
+ " be :{}".format(' or '.join(valid_log_levels)))
+
+ if 'EventURL' in module_parms:
+ CEPH.event_url = module_parms['EventURL']
+ collectd.info("cephmetrics: Event messages enabled for target "
+ "{}".format(CEPH.event_url))
+ else:
+ collectd.warning("cephmetrics: EventURL missing - health events "
+ "will not be reported")
+
+ if 'ClusterName' in module_parms:
+ cluster_name = module_parms['ClusterName']
+ # cluster name is all we need to get started
+ if not os.path.exists('/etc/ceph/{}.conf'.format(cluster_name)):
+ collectd.error("Clustername given ('{}') not found in "
+ "/etc/ceph".format(module_parms['ClusterName']))
+
+ # let's assume the conf file is OK to use
+ CEPH.cluster_name = cluster_name
+
+ setup_module_logging(log_level)
+
+ CEPH.probe()
+
+ collectd.info("{}: Roles detected - "
+ "mon:{} osd:{} rgw:{} "
+ "iscsi:{}".format(__name__,
+ isinstance(CEPH.mon, Mon),
+ isinstance(CEPH.osd, OSDs),
+ isinstance(CEPH.rgw, RGW),
+ isinstance(CEPH.iscsi, ISCSIGateway)))
+ else:
+ collectd.error("cephmetrics: ClusterName is required")
+
+
+def setup_module_logging(log_level):
+
+ level = {"debug": logging.DEBUG,
+ "info": logging.INFO}
+
+ logging.getLogger('cephmetrics')
+ logging.basicConfig(filename='/var/log/collectd-cephmetrics.log',
+ format='%(asctime)s - %(levelname)-7s - '
+ '[%(filename)s:%(lineno)s:%(funcName)s() - '
+ '%(message)s',
+ filemode='w',
+ level=level.get(log_level))
+
+
+def read_callback():
+
+ stats = CEPH.get_stats()
+
+ for role in Ceph.roles:
+ if role in stats:
+ collector = getattr(CEPH, role)
+
+ write_stats(collector.all_metrics, stats[role])
+
+ error_handler(collector)
+
+
+def error_handler(collector):
+ if not collector.error:
+ return
+
+ # detected an error, let's flag it to the collectd log
+ msg_text = ",".join(collector.error_msgs)
+
+ collectd.error("cephmetrics error: {} - {}".format(collector._name,
+ msg_text))
+
+ # reset the collector instance's error tracking
+ collector.error = False
+ del collector.error_msgs[:]
+
+
+if __name__ == '__main__':
+
+ # run interactively or maybe test the code
+
+ pass
+
+else:
+
+ CEPH = Ceph()
+
+ collectd.register_config(configure_callback)
+ collectd.register_read(read_callback)
--- /dev/null
+%define debug_package %{nil}
+
+%{!?_selinux_policy_version: %global _selinux_policy_version %(sed -e 's,.*selinux-policy-\\([^/]*\\)/.*,\\1,' /usr/share/selinux/devel/policyhelp 2>/dev/null)}
+
+Name: cephmetrics
+Version: @VERSION@
+Release: @RELEASE@%{?dist}
+Summary: Monitoring service for Ceph clusters
+
+License: GPLv3
+URL: https://github.com/ceph/cephmetrics
+Source0: cephmetrics-@VERSION@.zip
+Source1: vonage-status-panel-1.0.4.zip
+Source2: grafana-piechart-panel-1.1.5.zip
+
+# SELinux deps
+BuildRequires: checkpolicy
+BuildRequires: selinux-policy-devel
+BuildRequires: /usr/share/selinux/devel/policyhelp
+BuildRequires: hardlink
+Requires: policycoreutils, libselinux-utils
+Requires(post): selinux-policy >= %{_selinux_policy_version}, policycoreutils
+Requires(postun): policycoreutils
+
+Requires: graphite-web
+Requires: python-carbon
+Requires: cephmetrics-grafana-plugins = %{version}-%{release}
+
+%description
+The monitoring service with web frontend for Ceph storage clusters providing several statistical data graphed by grafana.
+
+
+%package grafana-plugins
+Summary: Vonage plugin for graphana
+Requires: grafana
+License: ASL 2.0
+%description grafana-plugins
+The vonage status panel and piechart panel for grafana web server.
+
+
+%package collectors
+Summary: Ceph metrics collectors
+Requires: collectd
+Requires: collectd-python
+%description collectors
+The collectors for Ceph implemented with help of statistics collection daemon collectd.
+
+
+%package ansible
+Summary: Ansible playbooks for Ceph metrics
+Requires: ceph-ansible
+%description ansible
+Ansible playbooks for Ceph metrics
+
+
+%prep
+%setup -q
+unzip %SOURCE1
+mv -f Vonage* cephmetrics-vonage
+unzip %SOURCE2
+mv -f grafana-piechart-panel* cephmetrics-piechart
+
+
+%build
+make -f /usr/share/selinux/devel/Makefile cephmetrics.pp
+
+# Change the devel_mode defaults
+sed -i -e 's/devel_mode: true/devel_mode: false/' ansible/roles/*/defaults/main.yml
+
+# Support light mode better
+sed -i -e 's/green/rgb(1,167,1)/g' cephmetrics-vonage/dist/css/status_panel.css
+
+
+%install
+# Install dashUpdater.py
+install -d %{buildroot}%{_libexecdir}/cephmetrics
+install -m 755 dashUpdater.py %{buildroot}%{_libexecdir}/cephmetrics/
+install -d %{buildroot}%{_datadir}/cephmetrics/dashboards
+install -m 644 dashboards/current/* %{buildroot}%{_datadir}/cephmetrics/dashboards/
+
+# Install vonage and piechart plugin
+install -d %{buildroot}%{_localstatedir}/lib/grafana/plugins/
+cp -r cephmetrics-vonage %{buildroot}%{_localstatedir}/lib/grafana/plugins/
+cp -r cephmetrics-piechart %{buildroot}%{_localstatedir}/lib/grafana/plugins/
+
+# Install collectors
+install -d %{buildroot}%{_libdir}/collectd/cephmetrics/collectors
+install -m 755 cephmetrics.py %{buildroot}%{_libdir}/collectd/cephmetrics
+install -m 644 collectors/* %{buildroot}%{_libdir}/collectd/cephmetrics/collectors
+
+# Install ansible playbooks
+install -d %{buildroot}%{_datadir}
+cp -L -r ansible %{buildroot}%{_datadir}/cephmetrics-ansible
+
+# Install SELinux
+install -d %{buildroot}%{_datadir}/selinux/packages
+install -m 644 cephmetrics.pp %{buildroot}%{_datadir}/selinux/packages/cephmetrics.pp
+exit 0
+
+
+%files
+%{_libexecdir}/cephmetrics/dashUpdater.py
+%{_datadir}/cephmetrics
+%doc dashboard.yml
+%doc etc/grafana
+%doc LICENSE
+%doc README
+
+%files grafana-plugins
+%{_localstatedir}/lib/grafana/plugins/cephmetrics-vonage
+%{_localstatedir}/lib/grafana/plugins/cephmetrics-piechart
+
+%files collectors
+%{_libdir}/collectd/cephmetrics
+%doc etc/collectd.conf
+%doc etc/collectd.d
+%{_datadir}/selinux/packages/cephmetrics.pp
+
+%post collectors
+/usr/sbin/semodule -i %{_datadir}/selinux/packages/cephmetrics.pp &> /dev/null || :
+
+%postun collectors
+if [ $1 == 0 ] ; then
+ /usr/sbin/semodule -r cephmetrics &> /dev/null || :
+fi
+
+%files ansible
+%{_datadir}/cephmetrics-ansible
+
+%changelog
--- /dev/null
+#!/usr/bin/env python
+
+import json
+import time
+import logging
+import glob
+import os
+
+from ceph_daemon import admin_socket
+from collectors.common import os_cmd
+
+
+class BaseCollector(object):
+
+ class_to_cmd = {
+ "Mon": "ceph-mon",
+ "RGW": "radosgw",
+ "OSDs": "ceph-osd"
+ }
+
+ def __init__(self, parent, cluster_name, admin_socket=None):
+ self._name = self.__class__.__name__
+ self._parent = parent
+ self.cluster_name = cluster_name
+ self.admin_socket = admin_socket
+ self.version = self.get_version()
+ self.error = False
+ self.error_msgs = []
+
+ self.logger = logging.getLogger('cephmetrics')
+
+ self.logger.info("ceph version for {}: {}".format(self._name,
+ self.version))
+
+ def _admin_socket(self, cmds=None, socket_path=None):
+
+ adm_socket = self.admin_socket if not socket_path else socket_path
+
+ if not cmds:
+ cmds = ['perf', 'dump']
+
+ start = time.time()
+ response = admin_socket(adm_socket, cmds,
+ format='json')
+ end = time.time()
+
+ self.logger.debug("admin_socket call '{}' : "
+ "{:.3f}s".format(' '.join(cmds),
+ (end - start)))
+
+ return json.loads(response)
+
+ def get_version(self):
+ """
+ Although the version number is v.r.m based, this isn't a float so it
+ can't be stored as a number, so the version returned is just the
+ vesion.release components (i.e. looks like a float!)
+
+ :return: version number (float)
+ """
+ # version command returns output like this
+ # ceph version 10.2.2-15.el7cp (60cd52496ca02bdde9c2f4191e617f75166d87b6)
+
+ cmd = BaseCollector.class_to_cmd.get(self._name, 'ceph')
+ vers_command = "{} --version".format(cmd)
+ vers_output = os_cmd(vers_command)
+ if vers_output:
+ return float('.'.join(vers_output.split()[2].split('.')[:2]))
+ else:
+ return 0
+
+ @classmethod
+ def probe(cls, cluster_name, daemon_type):
+ """
+ Look for an admin socket related to the daemon
+ :param cluster_name: (str) cluster name
+ :param daemon_type: (str) mon, rgw, osd
+ :return: (list) list of socket paths or null list
+ """
+
+ daemon_pfx = {
+ "rgw": '{}-client.rgw'.format(cluster_name),
+ "osd": '{}-osd'.format(cluster_name),
+ "mon": '{}-mon'.format(cluster_name)
+ }
+
+ socket_path = os.path.join('/var/run/ceph/',
+ '{}.*.asok'.format(daemon_pfx[daemon_type]))
+
+ return glob.glob(socket_path)
+
+ def get_stats(self):
+
+ return {}
--- /dev/null
+#!/usr/bin/env python
+
+
+import socket
+import os
+import subprocess
+
+
+def cmd_exists(command):
+ return any(
+ os.access(os.path.join(path, command), os.X_OK)
+ for path in os.environ["PATH"].split(os.pathsep)
+ )
+
+
+def os_cmd(command):
+ """
+ Issue a command to the OS and return the output. NB. check_output default
+ is shell=False
+ :param command: (str) OS command
+ :return: (list) command response
+ """
+ cmd_list = command.split(' ')
+ if cmd_exists(cmd_list[0]):
+ cmd_output = subprocess.check_output(cmd_list).rstrip()
+ return cmd_output
+ else:
+ return ''
+
+
+def get_hostname():
+ return socket.gethostname().split('.')[0]
+
+
+def get_names():
+ return [get_hostname()]
+
+
+def add_dicts(dict1, dict2):
+ """
+ Add dictionary values together
+ :param dict1:
+ :param dict2:
+ :return: dict with matching fields sum'd together
+ """
+ return {key: dict1.get(key, 0) + dict2.get(key, 0)
+ for key in set(dict1).union(dict2)}
+
+
+def merge_dicts(dict1, dict2):
+ """
+ merges two dicts together to form a single dict. when dict keys overlap
+ the value in the 2nd dict takes precedence
+ :param dict1:
+ :param dict2:
+ :return: combined dict
+ """
+
+ new = dict1.copy()
+ new.update(dict2)
+
+ return new
+
+
+def flatten_dict(data, separator='.', prefix=''):
+ """
+ flatten a dict, so it is just simple key/value pairs
+ :param data: (dict)
+ :param separator: (str) char to use when combining keys
+ :param prefix: key prefix
+ :return:
+ """
+ return {prefix + separator + k if prefix else k: v
+ for kk, vv in data.items()
+ for k, v in flatten_dict(vv, separator, kk).items()
+ } if isinstance(data, dict) else {prefix: data}
+
+
+def todict(obj):
+ """
+ convert an object to a dict representation
+ :param obj: (object) object to examine, to extract variables/values from
+ :return: (dict) representation of the given object
+ """
+ data = {}
+ for key, value in obj.__dict__.iteritems():
+
+ if key.startswith('_'):
+ continue
+
+ try:
+ data[key] = todict(value)
+ except AttributeError:
+ data[key] = value
+
+ return data
+
+
+def fread(file_name=None):
+ """
+ Simple read function for files of a single value
+ :param file_name: (str) file name to read
+ :return: (str) contents of the file, or null string for empty file
+ """
+ if os.path.exists(file_name):
+ with open(file_name, 'r') as f:
+ setting = f.read().rstrip()
+ return setting
+ else:
+ return ''
+
+
+def freadlines(file_name=None):
+ """
+ simple readlines function to return all records of a given file
+ :param file_name: (str) file name to read
+ :return: (list) contents of the file, empty if file doesn't exist
+ """
+
+ if os.path.exists(file_name):
+ with open(file_name, 'r') as f:
+ data = f.readlines()
+ return data
+ else:
+ return []
+
+
+
+class IOstat(object):
+ raw_metrics = [
+ "_reads",
+ "_reads_mrgd",
+ "_sectors_read",
+ "_read_ms",
+ "_writes",
+ "_writes_mrgd",
+ "_sectors_written",
+ "_write_ms",
+ "_current_io",
+ "_ms_active_io",
+ "_ms_active_io_w"
+ ]
+
+ sector_size = 512
+
+ metrics = {
+ "iops": ("iops", "gauge"),
+ "r_iops": ("r_iops", "gauge"),
+ "w_iops": ("w_iops", "gauge"),
+ "bytes_per_sec": ("bytes_per_sec", "gauge"),
+ "r_bytes_per_sec": ("r_bytes_per_sec", "gauge"),
+ "w_bytes_per_sec": ("w_bytes_per_sec", "gauge"),
+ "util": ("util", "gauge"),
+ "await": ("await", "gauge"),
+ "r_await": ("r_await", "gauge"),
+ "w_await": ("w_await", "gauge"),
+ }
+
+ def __init__(self):
+ self._previous = []
+ self._current = []
+
+ # Seed the metrics we're interested in
+ for ctr in IOstat.metrics.keys():
+ setattr(self, ctr, 0)
+
+ def __str__(self):
+ s = '\n- IOstat object:\n'
+ for key in sorted(vars(self)):
+ s += '\t{} ... {}\n'.format(key, getattr(self, key))
+ return s
+
+ def _calc_raw_delta(self):
+ if not self._previous:
+ # nothing to compute yet
+ for ptr in range(len(IOstat.raw_metrics)):
+ key = IOstat.raw_metrics[ptr]
+ setattr(self, key, 0)
+ else:
+ for ptr in range(len(IOstat.raw_metrics)):
+ key = IOstat.raw_metrics[ptr]
+ setattr(self, key, (int(self._current[ptr]) -
+ int(self._previous[ptr])))
+
+ def compute(self, sample_interval):
+ """
+ Calculate the iostats for this device
+ """
+
+ self._calc_raw_delta()
+
+ if sample_interval > 0:
+ interval_ms = sample_interval * 1000
+ total_io = self._reads + self._writes
+ self.util = float(self._ms_active_io) / interval_ms * 100
+ self.iops = int(total_io) / sample_interval
+ self.r_iops = int(self._reads) / sample_interval
+ self.w_iops = int(self._writes) / sample_interval
+ self.await = float(
+ self._write_ms + self._read_ms) / total_io if total_io > 0 else 0
+ self.w_await = float(
+ self._write_ms) / self._writes if self._writes > 0 else 0
+ self.r_await = float(
+ self._read_ms) / self._reads if self._reads > 0 else 0
+ self.r_bytes_per_sec = (float(
+ self._sectors_read * IOstat.sector_size)) / sample_interval
+ self.w_bytes_per_sec = (float(
+ self._sectors_written * IOstat.sector_size)) / sample_interval
+ self.bytes_per_sec = self.r_bytes_per_sec + self.w_bytes_per_sec
+
+
+class Disk(object):
+
+ metrics = {
+ "rotational": ("rotational", "gauge"),
+ "disk_size": ("disk_size", "gauge"),
+ "osd_id": ("osd_id", "gauge")
+ }
+
+ osd_types = {"filestore": 0,
+ "bluestore": 1}
+
+ def __init__(self, device_name, path_name=None, osd_id=None,
+ in_osd_type="filestore", encrypted=0):
+
+ self._name = device_name
+ self._path_name = path_name
+ self._base_dev = Disk.get_base_dev(device_name)
+ self.osd_id = osd_id
+
+ self.rotational = self._get_rota()
+ self.disk_size = self._get_size()
+ self.perf = IOstat()
+ self.encrypted = encrypted
+ self.osd_type = Disk.osd_types[in_osd_type]
+
+ def _get_size(self):
+ size = fread("/sys/block/{}/size".format(self._base_dev))
+ if size.isdigit():
+ size = int(size) * 512
+ else:
+ size = 0
+ return size
+
+ def _get_rota(self):
+ rota = fread("/sys/block/{}/queue/rotational".format(self._base_dev))
+ if rota.isdigit():
+ # 0 = flash/nvme/ssd, 1 = HDD
+ return rota
+ else:
+ # default to a HDD response
+ return 1
+
+ @staticmethod
+ def get_base_dev(dev_name):
+
+ # for intelcas devices, just use the device name as is
+ if dev_name.startswith('intelcas'):
+ device = dev_name
+ elif dev_name.startswith('nvme'):
+ if 'p' in dev_name:
+ device = dev_name[:(dev_name.index('p'))]
+ else:
+ device = dev_name
+ else:
+ # default strip any numeric ie. sdaa1 -> sdaa
+ device = filter(lambda ch: ch.isalpha(), dev_name)
+
+ return device
+
--- /dev/null
+#!/usr/bin/env python2
+
+# requires python-rtslib_fb for LIO interaction
+#
+# NB. the rtslib_fb module is dynamically loaded by the ISCSIGateway
+# class instantiation. This prevents import errors within the generic parent
+# module cephmetrics
+#
+import os
+import sys
+import time
+
+from collectors.base import BaseCollector
+from collectors.common import fread
+
+
+class Client(object):
+
+ def __init__(self, iqn):
+ self.iqn = iqn
+ self.name = iqn.replace('.', '-')
+ self.luns = {}
+ self.lun_count = 0
+ self._cycle = 0
+
+ def dump(self):
+ client_dump = {}
+ lun_info = {}
+ client_dump[self.name] = {"luns": {},
+ "lun_count": self.lun_count}
+ for lun_name in self.luns:
+ lun = self.luns[lun_name]
+ lun_info.update(lun.dump())
+
+ return {self.name: {"luns": lun_info,
+ "lun_count": len(lun_info)}
+ }
+
+
+class LUN(object):
+
+ def __init__(self, client, tpg_lun):
+ self._path = tpg_lun.storage_object.path
+ self._tpg_lun = tpg_lun
+ self._name = tpg_lun.storage_object.name
+ self._display_name = tpg_lun.storage_object.name.replace('.', "-")
+ self._so = tpg_lun.storage_object
+ self._client = client
+ self._cycle = 0
+ self.size = 0
+ self.iops = 0
+ self.read_bytes_per_sec = 0
+ self.write_bytes_per_sec = 0
+ self.total_bytes_per_sec = 0
+ self.active_path = 0
+
+ def refresh(self, cycle_id):
+ self._cycle = cycle_id
+ self.size = self._so.size
+ stats_path = os.path.join(self._path, 'statistics/scsi_lu')
+ self.iops = int(fread(os.path.join(stats_path, "num_cmds")))
+ read_mb = float(fread(os.path.join(stats_path, "read_mbytes")))
+ write_mb = float(fread(os.path.join(stats_path, "write_mbytes")))
+ self.read_bytes_per_sec = int(read_mb * 1024 ** 2)
+ self.write_bytes_per_sec = int(write_mb * 1024 ** 2)
+ self.total_bytes_per_sec = self.read_bytes_per_sec + \
+ self.write_bytes_per_sec
+
+ if self._tpg_lun.alua_tg_pt_gp_name == 'ao':
+ self.active_path = 1
+ else:
+ self.active_path = 0
+
+ def dump(self):
+ return {self._display_name: {k: getattr(self, k) for k in self.__dict__
+ if not k.startswith("_")}}
+
+
+class ISCSIGateway(BaseCollector):
+ """
+ created on a host that has a /sys/kernel/config/target/iscsi dir
+ i.e. there is an iscsi gateway here!
+ """
+
+ all_metrics = {
+ "lun_count": ("lun_count", "gauge"),
+ "client_count": ("client_count", "gauge"),
+ "tpg_count": ("tpg_count", "gauge"),
+ "sessions": ("sessions", "gauge"),
+ "capacity": ("capacity", "gauge"),
+ "iops": ("iops", "derive"),
+ "read_bytes_per_sec": ("read_bytes_per_sec", "derive"),
+ "write_bytes_per_sec": ("write_bytes_per_sec", "derive"),
+ "total_bytes_per_sec": ("total_bytes_per_sec", "derive")
+ }
+
+ def __init__(self, *args, **kwargs):
+ BaseCollector.__init__(self, *args, **kwargs)
+
+ # Since the module can be imported by a parent class but not
+ # instantiated, the rtslib import is deferred until the first instance
+ # of the the class is created. This keeps the parent module simple
+ # and more importantly generic
+ if 'rtslib_fb.root' not in sys.modules.keys():
+
+ try:
+ import rtslib_fb.root as RTSRoot
+ except ImportError:
+ raise
+
+ self._root = RTSRoot()
+
+ self.clients = {}
+ self.cycle = 0
+
+ self.iops = 0
+ self.read_bytes_per_sec = 0
+ self.write_bytes_per_sec = 0
+ self.total_bytes_per_sec = 0
+
+ def refresh(self):
+ """
+ populate the instance by exploring rtslib
+ """
+
+ self.iops = 0
+ self.read_bytes_per_sec = 0
+ self.write_bytes_per_sec = 0
+ self.total_bytes_per_sec = 0
+
+ if self.cycle == 10:
+ self.cycle = 0
+ else:
+ self.cycle += 1
+
+ for node_acl in self._root.node_acls:
+
+ client_name = node_acl.node_wwn
+
+ if client_name not in self.clients:
+ new_client = Client(client_name)
+ self.clients[client_name] = new_client
+
+ client = self.clients[client_name]
+ client.lun_count = 0
+ client._cycle = self.cycle
+
+ for lun in node_acl.mapped_luns:
+ client.lun_count += 1
+ tpg_lun = lun.tpg_lun
+ lun_name = tpg_lun.storage_object.name
+ if lun_name not in client.luns:
+ lun = LUN(client, tpg_lun)
+ client.luns[lun._name] = lun
+ else:
+ lun = client.luns[lun_name]
+
+ lun.refresh(self.cycle)
+
+ self.iops += lun.iops
+ self.read_bytes_per_sec += lun.read_bytes_per_sec
+ self.write_bytes_per_sec += lun.write_bytes_per_sec
+ self.total_bytes_per_sec = self.read_bytes_per_sec + \
+ self.write_bytes_per_sec
+
+ def prune(self):
+ """
+ drop child objects held by the instance, that are no longer in the
+ iSCSI config i.e. don't report on old information
+ """
+
+ for client_name in self.clients:
+ client = self.clients[client_name]
+
+ for lun_name in client.luns:
+ lun = client.luns[lun_name]
+ if lun._cycle != self.cycle:
+ # drop the lun entry
+ self.logger.debug("pruning LUN '{}'".format(lun_name))
+
+ del client.luns[lun_name]
+
+ if client._cycle != self.cycle:
+ # drop the client entry
+ self.logger.debug("pruning client '{}'".format(client_name))
+ del self.clients[client_name]
+
+ def dump(self):
+
+ gw_stats = {}
+ client_stats = {}
+
+ for metric in ISCSIGateway.all_metrics:
+ gw_stats[metric] = getattr(self, metric)
+
+ for client_name in self.clients:
+ client = self.clients[client_name]
+ client_stats.update(client.dump())
+
+ return {"iscsi": {
+ "ceph_version": self.version,
+ "gw_name": {self.gateway_name: 0},
+ "gw_stats": gw_stats,
+ "gw_clients": client_stats
+ }
+ }
+
+ def _get_so(self):
+ return [so for so in self._root.storage_objects]
+
+ def _get_node_acls(self):
+ return [node for node in self._root.node_acls]
+
+ @property
+ def tpg_count(self):
+ return len([tpg for tpg in self._root.tpgs])
+
+ @property
+ def lun_count(self):
+ return len(self._get_so())
+
+ @property
+ def sessions(self):
+ return len([session for session in self._root.sessions])
+
+ @property
+ def gateway_name(self):
+ # Only the 1st gateway is considered/supported
+ gw_iqn = [gw.wwn for gw in self._root.targets][0]
+ return gw_iqn.replace('.', '-')
+
+ @property
+ def client_count(self):
+ return len(self._get_node_acls())
+
+ @property
+ def capacity(self):
+ return sum([so.size for so in self._get_so()])
+
+ def get_stats(self):
+
+ start = time.time()
+
+ # populate gateway instance with the latest configuration from rtslib
+ self.refresh()
+
+ # Overtime they'll be churn in client and disks so we need to drop
+ # any entries from prior runs that are no longer seen in the iscsi
+ # configuration with the prune method
+ self.prune()
+
+ end = time.time()
+
+ self.logger.info("LIO stats took {}s".format(end - start))
+
+ return self.dump()
+
+ @classmethod
+ def probe(cls):
+ return os.path.exists('/sys/kernel/config/target/iscsi')
--- /dev/null
+#!/usr/bin/env python
+
+import rados
+import rbd
+import json
+import threading
+import time
+import logging
+import requests
+
+from collectors.base import BaseCollector
+from collectors.common import merge_dicts, get_hostname, get_names
+
+
+class CephState(object):
+
+ def __init__(self, status=None, summary_list=[]):
+ self.status = status
+
+ # create a list of health issues, ignoring the warning that Luminous
+ # issues
+ summary_data = [health_issue.get('summary', '')
+ for health_issue in summary_list]
+ self.summary = [health_desc for health_desc in summary_data
+ if health_desc.find('update your health monitoring') == -1]
+
+ def update(self, state_object):
+ self.status = state_object.status
+ self.summary = state_object.summary
+
+ @property
+ def status_items(self):
+ """
+ The summary text will track pgs objects during recovery or backfill
+ operations, so every status could be different from the last as these
+ counts change. this function removes the int(s) from the status text
+ to reduce the frequency that a status check would generate an event
+ :return: items (set) unique set of status items
+ """
+ priority_errors = ['mons', 'osds', 'flag(s)']
+
+ items = set()
+ for summary_text in self.summary:
+ if any(prio_field in summary_text
+ for prio_field in priority_errors):
+ # priority health messages kept as is
+ items.add(summary_text)
+ else:
+ # other messages get their 'counts' removed
+ new_text = filter(lambda x: not x.isdigit(), summary_text)
+ items.add(new_text)
+
+ return items
+
+ @property
+ def status_str(self):
+ return "{} : {}".format(self.status,
+ ','.join(self.summary))
+
+
+class RBDScanner(threading.Thread):
+
+ def __init__(self, cluster_name, pool_name):
+ self.cluster_name = cluster_name
+ self.pool_name = pool_name
+ self.num_rbds = 0
+ self.logger = logging.getLogger('cephmetrics')
+
+ threading.Thread.__init__(self)
+
+ def run(self):
+ rbd_images = []
+ conf_file = "/etc/ceph/{}.conf".format(self.cluster_name)
+ self.logger.debug("scan of '{}' starting".format(self.pool_name))
+ with rados.Rados(conffile=conf_file) as cluster:
+ with cluster.open_ioctx(self.pool_name) as ioctx:
+ rbd_inst = rbd.RBD()
+ self.logger.debug("listing rbd's in {}".format(self.pool_name))
+ rbd_images = rbd_inst.list(ioctx)
+
+ self.logger.info("pool scan complete for '{}'".format(self.pool_name))
+ self.num_rbds = len(rbd_images)
+
+
+class Mon(BaseCollector):
+
+ health = {
+ "HEALTH_OK": 0,
+ "HEALTH_WARN": 4,
+ "HEALTH_ERR": 8
+ }
+
+ osd_state = {
+ "up": 0,
+ "down": 1
+ }
+
+ # metrics are declared, where each element has a description and collectd
+ # data type. The description is used to ensure the names sent by collectd
+ # remain the same even if the source name changes in ceph.
+ cluster_metrics = {
+ "num_mon": ("num_mon", "gauge"),
+ "num_mon_quorum": ("num_mon_quorum", "gauge"),
+ "num_rbds": ("num_rbds", "gauge"),
+ "num_osd_hosts": ("num_osd_hosts", "gauge"),
+ "num_osd": ("num_osd", "gauge"),
+ "num_osd_up": ("num_osd_up", "gauge"),
+ "num_osd_in": ("num_osd_in", "gauge"),
+ "osd_epoch": ("osd_epoch", "gauge"),
+ "osd_bytes": ("osd_bytes", "gauge"),
+ "osd_bytes_used": ("osd_bytes_used", "gauge"),
+ "osd_bytes_avail": ("osd_bytes_avail", "gauge"),
+ "num_pool": ("num_pool", "gauge"),
+ "num_pg": ("num_pg", "gauge"),
+ "num_pg_active_clean": ("num_pg_active_clean", "gauge"),
+ "num_pg_active": ("num_pg_active", "gauge"),
+ "num_pg_peering": ("num_pg_peering", "gauge"),
+ "num_object": ("num_object", "gauge"),
+ "num_object_degraded": ("num_object_degraded", "gauge"),
+ "num_object_misplaced": ("num_object_misplaced", "gauge"),
+ "num_object_unfound": ("num_object_unfound", "gauge"),
+ "num_bytes": ("num_bytes", "gauge"),
+ "num_mds_up": ("num_mds_up", "gauge"),
+ "num_mds_in": ("num_mds_in", "gauge"),
+ "num_mds_failed": ("num_mds_failed", "gauge"),
+ "mds_epoch": ("mds_epoch", "gauge"),
+ "health": ("health", "gauge")
+ }
+
+ pool_client_metrics = {
+ 'bytes_sec': ("bytes_sec", "gauge"),
+ 'op_per_sec': ("op_per_sec", "gauge"),
+ 'read_bytes_sec': ("read_bytes_sec", "gauge"),
+ 'write_op_per_sec': ("write_op_per_sec", "gauge"),
+ 'write_bytes_sec': ("write_bytes_sec", "gauge"),
+ 'read_op_per_sec': ("read_op_per_sec", "gauge")
+ }
+
+ pool_recovery_metrics = {
+ "recovering_objects_per_sec": ("recovering_objects_per_sec", "gauge"),
+ "recovering_bytes_per_sec": ("recovering_bytes_per_sec", "gauge"),
+ "recovering_keys_per_sec": ("recovering_keys_per_sec", "gauge"),
+ "num_objects_recovered": ("num_objects_recovered", "gauge"),
+ "num_bytes_recovered": ("num_bytes_recovered", "gauge"),
+ "num_keys_recovered": ("num_keys_recovered", "gauge")
+ }
+
+ mon_states = {
+ "mon_status": ("mon_status", "gauge")
+ }
+
+ all_metrics = merge_dicts(pool_recovery_metrics, pool_client_metrics)
+ all_metrics = merge_dicts(all_metrics, cluster_metrics)
+ all_metrics = merge_dicts(all_metrics, mon_states)
+
+ def __init__(self, *args, **kwargs):
+ BaseCollector.__init__(self, *args, **kwargs)
+
+ self.last_state = CephState()
+
+ self.ip_names = get_names()
+
+ if self.version < 12:
+ self.get_mon_health = self._mon_health
+ else:
+ self.get_mon_health = self._mon_health_new
+
+
+
+ if self._parent:
+ self.logger.debug("Event URL is : "
+ "{}".format(self._parent.event_url))
+
+ def _mon_command(self, cmd_request):
+ """ Issue a command to the monitor """
+
+ buf_s = '{}'
+ conf_file = "/etc/ceph/{}.conf".format(self.cluster_name)
+
+ start = time.time()
+ with rados.Rados(conffile=conf_file) as cluster:
+ cmd = {'prefix': cmd_request, 'format': 'json'}
+ rc, buf_s, out = cluster.mon_command(json.dumps(cmd), b'')
+ end = time.time()
+
+ self.logger.debug("_mon_command call '{}' :"
+ " {:.3f}s".format(cmd_request,
+ (end - start)))
+
+ return json.loads(buf_s)
+
+ @staticmethod
+ def get_feature_state(summary_data, pg_states):
+ """
+ Look at the summary list to determine the state of RADOS features
+ :param summary_data: (list) summary data from a ceph health command
+ :return: (dict) dict indexed by feature
+ 0 Inactive, 1 Active, 2 Disabled
+ """
+ feature_lookup = {"noscrub": "scrub",
+ "nodeep-scrub": "deep_scrub",
+ "norecover": "recovery",
+ "nobackfill": "backfill",
+ "norebalance": "rebalance",
+ "noout": "out",
+ "nodown": "down"}
+
+ # Start with all features inactive i.e. enabled
+ feature_state = {feature_lookup.get(key): 0 for key in feature_lookup}
+
+ for summary in summary_data:
+ summary_desc = summary.get('summary')
+ if "flag(s) set" in summary_desc:
+ flags = summary_desc.replace(' flag(s) set', '').split(',')
+ for disabled_feature in flags:
+ if disabled_feature in feature_lookup:
+ feature = feature_lookup.get(disabled_feature)
+ feature_state[feature] = 2 # feature disabled
+
+ # Now use the current pg state names to determine whether a feature is
+ # active - if not it stays set to '0', which means inactive
+ pg_state_names = [pg_state.get('name') for pg_state in pg_states]
+ for pg_state in pg_state_names:
+ states = pg_state.split('+')
+ if 'recovering' in states:
+ feature_state['recovery'] = 1 # Active
+ continue
+ if 'backfilling' in states:
+ feature_state['backfill'] = 1
+ continue
+ if 'deep' in states:
+ feature_state['deep_scrub'] = 1
+ continue
+ if 'scrubbing' in states:
+ feature_state['scrub'] = 1
+
+ return feature_state
+
+ @classmethod
+ def check_stuck_pgs(cls, summary_list):
+ bad_pg_words = ['pgs', 'stuck', 'inactive']
+ stuck_pgs = 0
+ for summary_data in summary_list:
+ if summary_data.get('severity') != 'HEALTH_ERR':
+ continue
+ if all(trigger in summary_data.get('summary')
+ for trigger in bad_pg_words):
+ stuck_pgs = int(summary_data.get('summary').split()[0])
+
+ return stuck_pgs
+
+ def _mon_health_new(self):
+
+ cluster, health_data = self._mon_health_common()
+
+ mon_status_output = self._mon_command('mon_status')
+ quorum_list = mon_status_output.get('quorum')
+ mon_list = mon_status_output.get('monmap').get('mons')
+ mon_status = {}
+ for mon in mon_list:
+ state = 0 if mon.get('rank') in quorum_list else 4
+ mon_status[mon.get('name')] = state
+
+ cluster['mon_status'] = mon_status
+
+ self.manage_event(health_data.get('status'),
+ health_data.get('summary', []),
+ mon_status)
+
+ return cluster
+
+ def _mon_health_common(self):
+
+ # for v12 (Luminous and beyond) add the following setting to
+ # ceph.conf "mon_health_preluminous_compat=true"
+ # this will provide the same output as pre-luminous
+
+ cluster_data = self._admin_socket().get('cluster')
+ pg_data = self._mon_command("pg stat")
+ health_data = self._mon_command("health")
+ health_text = health_data.get('status',
+ health_data.get('overall_status', ''))
+
+ cluster = {Mon.cluster_metrics[k][0]: cluster_data[k]
+ for k in cluster_data}
+
+ health_num = Mon.health.get(health_text, 16)
+
+ cluster['health'] = health_num
+
+ pg_states = pg_data.get('num_pg_by_state') # list of dict name,num
+ health_summary = health_data.get('summary', []) # list of issues
+ cluster['num_pgs_stuck'] = Mon.check_stuck_pgs(health_summary)
+ cluster['features'] = Mon.get_feature_state(health_summary,
+ pg_states)
+
+ self.logger.debug(
+ 'Features:{}'.format(json.dumps(cluster['features'])))
+
+ return cluster, health_data
+
+ def _mon_health(self):
+
+ cluster, health_data = self._mon_health_common()
+
+ services = health_data.get('health').get('health_services')
+ mon_status = {}
+ for svc in services:
+ if 'mons' in svc:
+ # Each monitor will have a numeric value denoting health
+ mon_status = {mon.get('name'): Mon.health.get(mon.get('health'))
+ for mon in svc.get('mons')}
+
+ cluster['mon_status'] = mon_status
+
+ self.manage_event(health_data.get('overall_status'),
+ health_data.get('summary', []),
+ mon_status)
+
+ return cluster
+
+ def manage_event(self, health_text, health_summary, mon_status):
+
+ if not self._parent:
+ # invoked without a parent, as part of system tests
+ return
+ elif not self._parent.event_url:
+ # event generation skipped
+ return
+
+ candidates = [mon_name for mon_name in sorted(mon_status)
+ if mon_status.get(mon_name) == 0]
+
+ if candidates:
+ sender = candidates[0]
+ if sender not in self.ip_names:
+ # only one mon should send, so if that's not us do nothing
+ return
+ else:
+ # no suitable mon to send the alert
+ self.logger.error("Unable to send ANY event - no valid mon "
+ "found")
+ return
+
+ # If we're here, the current host is suitable to send an event so lets
+ # look deeper to see if we need to
+
+ current_state = CephState(health_text, health_summary)
+ self.logger.debug("health:{}".format(current_state.status))
+ self.logger.debug("health:{}".format(current_state.summary))
+ send_it = False
+
+ if health_text != self.last_state.status:
+ # Overall health has changed, so just send the current state!
+ send_it = True
+ else:
+ # look deeper - only send if the list of issues is different
+ if health_text == 'HEALTH_OK':
+ # nothing to do, nothing to send
+ pass
+ else:
+ if self.last_state.status_items != current_state.status_items:
+ send_it = True
+
+ self.last_state.update(current_state)
+
+ if send_it:
+ tag = 'health_ok' if current_state.status == 'HEALTH_OK' \
+ else 'health_alert'
+
+ self.logger.info("sending cluster status to "
+ "{}".format(self._parent.event_url))
+ self.logger.debug(current_state.status_str)
+
+ rc = Mon.post_event(self._parent.event_url,
+ tag,
+ current_state.status_str)
+
+ if rc != 200:
+ self.error = True
+ self.error_msgs = ['POST request to {} failed ({}) - '
+ 'firewall?'.format(self._parent.event_url,
+ rc)]
+ self.logger.warning("Unable to send event - graphite response "
+ "{}".format(rc))
+
+ else:
+ # no real change to report
+ pass
+
+ @staticmethod
+ def post_event(url, tag_name, event_message):
+
+ headers = {"Content-Type": "application/json"}
+
+ try:
+ r = requests.post(url,
+ headers=headers,
+ data='{{"what":"Ceph Health",'
+ '"tags":"{}",'
+ '"data":"{}"}}'.format(tag_name,
+ event_message))
+ except requests.ConnectionError:
+ return 500
+
+ else:
+ return r.status_code
+
+ @classmethod
+ def _seed(cls, metrics):
+ return {metrics[key][0]: 0 for key in metrics}
+
+ def display_names(self, metric_format, metrics):
+ """
+ convert the keys to the static descriptions
+ :return:
+ """
+ return {metric_format[k][0]: metrics[k]
+ for k in metrics} if metrics else {}
+
+ def _get_pool_stats(self):
+ """ get pool stats from rados """
+
+ raw_stats = self._mon_command('osd pool stats')
+ pool_stats = {}
+
+ # process each pool
+ for pool in raw_stats:
+
+ pool_name = pool['pool_name'].replace('.', '_')
+ client_io = self.display_names(Mon.pool_client_metrics,
+ pool.get('client_io_rate'))
+ recovery = self.display_names(Mon.pool_recovery_metrics,
+ pool.get('recovery_rate'))
+
+ pool_md = {}
+ if client_io:
+
+ # Add pool level aggregation
+ client_io['bytes_sec'] = client_io.get('read_bytes_sec', 0) + \
+ client_io.get('write_bytes_sec', 0)
+ client_io["op_per_sec"] = client_io.get('read_op_per_sec', 0)+ \
+ client_io.get('write_op_per_sec', 0)
+ pool_md = client_io
+
+ else:
+ pool_md = Mon._seed(Mon.pool_client_metrics)
+
+ if recovery:
+ pool_md = merge_dicts(pool_md, recovery)
+ else:
+ pool_md = merge_dicts(pool_md, Mon._seed(
+ Mon.pool_recovery_metrics))
+
+ pool_stats[pool_name] = pool_md
+
+ return pool_stats
+
+ def _get_osd_states(self):
+
+ self.logger.debug("fetching osd states from the local mon")
+ raw = self._mon_command('osd dump')
+ osd_hosts = set()
+ osds = {}
+ for osd in raw.get('osds'):
+ cluster_addr = osd.get('cluster_addr').split(':')[0]
+ osd_hosts.add(cluster_addr)
+
+ # NB. The key for the osds dict must be a string as the dict is
+ # flattened when the metric name is derived in the parent collectd
+ # module. If it is not converted, you get a TypeError
+ osds[str(osd.get('osd'))] = {"up": osd.get('up'),
+ "in": osd.get('in')}
+
+ return len(osd_hosts), osds
+
+ @staticmethod
+ def _select_pools(pools, mons):
+ """
+ determine the pools this mon should scan based on it's name. We select
+ pools from the an offset into the pool list, and then repeat at an
+ interval set by # mons in the configuration. This splits up the pools
+ we have, so each mon looks at a discrete set of pools instead of all
+ mons performing all scans.
+ :param pools: (list) rados pool names
+ :param mons: (list) monitor names from ceph health
+ :return: (list) of pools this monitor should scan. empty list if the
+ monitor name mismatches - so no scans done
+ """
+
+ pools_to_scan = []
+
+ try:
+ freq = mons.index(get_hostname())
+ except ValueError:
+ # this host's name is not in the monitor list?
+ # twilight zone moment
+ pass
+ else:
+
+ pools_to_scan = [pools[ptr]
+ for ptr in xrange(freq, len(pools), len(mons))]
+
+ return pools_to_scan
+
+ def get_pools(self):
+ skip_pools = ('default.rgw')
+
+ start = time.time()
+ conf_file = "/etc/ceph/{}.conf".format(self.cluster_name)
+ with rados.Rados(conffile=conf_file) as cluster:
+ rados_pools = sorted(cluster.list_pools())
+ end = time.time()
+
+ self.logger.debug('lspools took {:.3f}s'.format(end - start))
+
+ filtered_pools = [pool for pool in rados_pools
+ if not pool.startswith(skip_pools)]
+
+ return filtered_pools
+
+ def _get_rbds(self, monitors):
+
+ pool_list = self.get_pools()
+ mon_list = sorted(monitors.keys())
+ my_pools = Mon._select_pools(pool_list, mon_list)
+ self.logger.debug("Pools to be scanned on this mon"
+ " : {}".format(','.join(my_pools)))
+ threads = []
+
+ start = time.time()
+
+ for pool in my_pools:
+ thread = RBDScanner(self.cluster_name, pool)
+ thread.start()
+ threads.append(thread)
+
+ # wait for all threads to complete
+ for thread in threads:
+ thread.join(1)
+
+ end = time.time()
+ self.logger.debug("rbd scans {:.3f}s".format((end - start)))
+
+ total_rbds = sum([thread.num_rbds for thread in threads])
+ self.logger.debug("total rbds found : {}".format(total_rbds))
+
+ for thread in threads:
+ del thread
+
+ return total_rbds
+
+ def get_stats(self):
+ """
+ method associated with the plugin callback to gather the metrics
+ :return: (dict) metadata describing the state of the mon/osd's
+ """
+
+ start = time.time()
+
+ pool_stats = self._get_pool_stats()
+ num_osd_hosts, osd_states = self._get_osd_states()
+ cluster_state = self.get_mon_health()
+ cluster_state['num_osd_hosts'] = num_osd_hosts
+ cluster_state['num_rbds'] = self._get_rbds(cluster_state['mon_status'])
+
+ all_stats = merge_dicts(cluster_state, {"pools": pool_stats,
+ "osd_state": osd_states})
+ all_stats['ceph_version'] = self.version
+
+ end = time.time()
+ self.logger.info("mon get_stats call : {:.3f}s".format((end - start)))
+
+ return {
+ "mon": all_stats
+ }
+
--- /dev/null
+#!/usr/bin/env python
+
+import os
+import time
+import math
+
+from collectors.base import BaseCollector
+from collectors.common import (todict, fread, freadlines, merge_dicts,
+ IOstat, Disk)
+
+
+class OSDstats(object):
+
+ osd_capacity = {
+ "stat_bytes": ("stat_bytes", "gauge"),
+ "stat_bytes_used": ("stat_bytes_used", "gauge"),
+ "stat_bytes_avail": ("stat_bytes_avail", "gauge")
+ }
+
+ perf_metrics = {
+ "filestore": {
+ "journal_latency",
+ "commitcycle_latency",
+ "apply_latency",
+ "queue_transaction_latency_avg"
+ },
+ "bluestore": {
+ "submit_lat",
+ "throttle_lat",
+ "state_aio_wait_lat",
+ "kv_flush_lat",
+ "kv_commit_lat"
+ }
+ }
+
+ def __init__(self, osd_type='filestore'):
+ self._current = {}
+ self._previous = {}
+ self._osd_type = osd_type
+ self.osd_type = Disk.osd_types[osd_type]
+ self.osd_percent_used = 0
+
+ def update(self, stats):
+ """
+ update the objects attributes based on the 'stats' dict
+ :param stats: (dict) containing performance ('filestore' or 'bluestore')
+ and capacity info ('osd')
+ :return: None
+ """
+
+ if self._current:
+ self._previous = self._current
+ self._current = stats[self._osd_type]
+ else:
+ self._current = stats[self._osd_type]
+
+ for attr in OSDstats.perf_metrics[self._osd_type]:
+
+ if attr not in self._current:
+ # skip if the attribute needed isn't available
+ # eg. early versions of bluestore didn't have a 'stable'
+ # set of perf counters
+ continue
+
+ if self._previous:
+ d_sum = self._current[attr].get('sum') - \
+ self._previous[attr].get('sum')
+ d_avgcount = self._current[attr].get('avgcount') - \
+ self._previous[attr].get('avgcount')
+
+ if d_sum == 0 or d_avgcount == 0:
+ val = 0
+ else:
+ val = float(d_sum) / d_avgcount
+ else:
+ # no previous value, so set to 0
+ val = 0
+
+ setattr(self, attr, val)
+
+ for attr in stats['osd']:
+ setattr(self, attr, stats['osd'].get(attr))
+
+ self.osd_percent_used = math.ceil((float(self.stat_bytes_used) /
+ self.stat_bytes) * 100)
+
+
+class OSDs(BaseCollector):
+
+ all_metrics = merge_dicts(Disk.metrics, IOstat.metrics)
+ supported_object_stores = ['filestore', 'bluestore']
+
+ def __init__(self, *args, **kwargs):
+ BaseCollector.__init__(self, *args, **kwargs)
+ self.timestamp = int(time.time())
+
+ self.osd = {} # dict of disk objects, each disk contains osd_id
+ self.jrnl = {} # dict of journal devices (if not collocated)
+ self.osd_id_list = []
+ self.dev_lookup = {} # dict dev_name -> osd | jrnl
+ self.osd_count = 0
+
+ def __repr__(self):
+
+ s = ''
+ for disk in self.osd:
+ s += "{}\n".format(disk)
+ dev = self.osd[disk]
+
+ for var in vars(dev):
+ if not var.startswith('_'):
+ s += "{} ... {}\n".format(var, getattr(dev, var))
+ return s
+
+ def _fetch_osd_stats(self, osd_id, osd_type='filestore'):
+
+ # NB: osd stats are cumulative
+
+ stats = {}
+ osd_socket_name = '/var/run/ceph/{}-osd.{}.asok'.format(self.cluster_name,
+ osd_id)
+
+ if not os.path.exists(osd_socket_name):
+ # all OSD's should expose an admin socket, so if it's missing
+ # the osd hasn't initialized properly or it's gone down
+ msg = "Socket file missing for OSD {}".format(osd_id)
+ self.logger.error(msg)
+ self.error = True
+ self.error_msg = msg
+ return
+
+ self.logger.debug("fetching osd stats for osd {}".format(osd_id))
+ resp = self._admin_socket(socket_path=osd_socket_name)
+
+ perf_stats = resp.get(osd_type)
+
+ stats[osd_type] = {key_name: perf_stats.get(key_name)
+ for key_name in OSDstats.perf_metrics[osd_type]}
+
+ osd_stats = resp.get('osd')
+
+ # Add disk usage stats
+ stats['osd'] = {key_name: osd_stats.get(key_name)
+ for key_name in OSDstats.osd_capacity.keys()}
+
+ return stats
+
+ @staticmethod
+ def get_osd_type(osd_path):
+
+ osd_type_fname = os.path.join(osd_path, 'type')
+ if os.path.exists(osd_type_fname):
+ return fread(osd_type_fname)
+ else:
+ if os.path.exists(os.path.join(osd_path, 'journal')):
+ return "filestore"
+ else:
+ raise ValueError("Unrecognised OSD type")
+
+ def _dev_to_osd(self):
+ """
+ Look at the system to determine which disks are acting as OSD's
+ """
+
+ # the logic here uses the mount points to determine which OSD's are
+ # in the system. The encryption state is determine just by the use
+ # devicemapper (i.e. /dev/mapper prefixed devices) - since at this time
+ # this is all dm is used for.
+
+ osd_indicators = {'var', 'lib', 'osd'}
+
+ for mnt in freadlines('/proc/mounts'):
+ items = mnt.split(' ')
+ dev_path, path_name = items[:2]
+ if path_name.startswith('/var/lib'):
+ # take a close look since this is where ceph osds usually
+ # get mounted
+ dirs = set(path_name.split('/'))
+ if dirs.issuperset(osd_indicators):
+
+ # get the osd_id from the name is the most simple way
+ # to get the id, due to naming conventions. If this fails
+ # though, plan 'b' is the whoami file
+ osd_id = path_name.split('-')[-1]
+ if not osd_id.isdigit():
+ osd_id = fread(os.path.join(path_name, 'whoami'))
+
+ if osd_id not in self.osd:
+ osd_type = OSDs.get_osd_type(path_name)
+ self.osd[osd_id] = OSDstats(osd_type=osd_type)
+ self.osd_id_list.append(osd_id)
+
+ osd_type = self.osd[osd_id]._osd_type
+ if osd_type == 'filestore':
+ if dev_path.startswith('/dev/mapper'):
+ encrypted = 1
+ uuid = dev_path.split('/')[-1]
+ partuuid = '/dev/disk/by-partuuid/{}'.format(uuid)
+ dev_path = os.path.realpath(partuuid)
+ osd_device = dev_path.split('/')[-1]
+ else:
+ encrypted = 0
+ osd_device = dev_path.split('/')[-1]
+
+ elif osd_type == 'bluestore':
+ block_link = os.path.join(path_name, 'block')
+ osd_path = os.path.realpath(block_link)
+ osd_device = osd_path.split('/')[-1]
+ encrypted = 0
+ else:
+ raise ValueError("Unknown OSD type encountered")
+
+ # if the osd_id hasn't been seem neither has the
+ # disk
+ self.osd[osd_device] = Disk(osd_device,
+ path_name=path_name,
+ osd_id=osd_id,
+ in_osd_type=osd_type,
+ encrypted=encrypted)
+ self.dev_lookup[osd_device] = 'osd'
+ self.osd_count += 1
+
+ if osd_type == 'filestore':
+ journal_link = os.path.join(path_name, 'journal')
+ else:
+ journal_link = os.path.join(path_name, 'block.wal')
+
+ if os.path.exists(journal_link):
+ link_tgt = os.readlink(journal_link)
+ if link_tgt.startswith('/dev/mapper'):
+ encrypted = 1
+ else:
+ encrypted = 0
+
+ partuuid_path = os.path.join('/dev/disk/by-partuuid',
+ link_tgt.split('/')[-1])
+ jrnl_path = os.path.realpath(partuuid_path)
+ jrnl_dev = jrnl_path.split('/')[-1]
+
+ if jrnl_dev not in self.osd:
+ self.jrnl[jrnl_dev] = Disk(jrnl_dev,
+ osd_id=osd_id,
+ in_osd_type=osd_type,
+ encrypted=encrypted)
+
+ self.dev_lookup[jrnl_dev] = 'jrnl'
+
+ else:
+ # No journal or WAL link..?
+ pass
+
+ def _stats_lookup(self):
+ """
+ Grab the disk stats from /proc/diskstats, and the key osd perf dump
+ counters
+ """
+
+ now = time.time()
+ interval = int(now) - self.timestamp
+ self.timestamp = int(now)
+
+ # Fetch diskstats from the OS
+ for perf_entry in freadlines('/proc/diskstats'):
+
+ field = perf_entry.split()
+ dev_name = field[2]
+
+ device = None
+ if self.dev_lookup.get(dev_name, None) == 'osd':
+ device = self.osd[dev_name]
+ elif self.dev_lookup.get(dev_name, None) == 'jrnl':
+ device = self.jrnl[dev_name]
+
+ if device:
+ new_stats = field[3:]
+
+ if device.perf._current:
+ device.perf._previous = device.perf._current
+ device.perf._current = new_stats
+ else:
+ device.perf._current = new_stats
+
+ device.perf.compute(interval)
+
+ end = time.time()
+ self.logger.debug("OS disk stats calculated in "
+ "{:.4f}s".format(end-now))
+
+ # fetch stats from each osd daemon
+ osd_stats_start = time.time()
+ for osd_id in self.osd_id_list:
+
+ osd_type = self.osd[osd_id]._osd_type
+
+ if osd_type in OSDs.supported_object_stores:
+
+ osd_stats = self._fetch_osd_stats(osd_id, osd_type)
+ osd_device = self.osd[osd_id]
+ osd_device.update(osd_stats)
+
+ else:
+ self.logger.warning("Unknown OSD type encountered for "
+ "osd.{}".format(osd_id))
+
+ osd_stats_end = time.time()
+ self.logger.debug("OSD perf dump stats collected for {} OSDs "
+ "in {:.3f}s".format(len(self.osd_id_list),
+ (osd_stats_end - osd_stats_start)))
+
+ @staticmethod
+ def _dump_devs(device_dict):
+
+ dumped = {}
+
+ for dev_name in sorted(device_dict):
+ device = device_dict[dev_name]
+ dumped[dev_name] = todict(device)
+
+ return dumped
+
+ def dump(self):
+ """
+ dump the osd object(s) to a dict. The object *must* not have references
+ to other objects - if this rule is broken cephmetrics caller will fail
+ when parsing the dict
+
+ :return: (dict) dictionary representation of this OSDs on this host
+ """
+
+ osds = OSDs._dump_devs(self.osd)
+ osds['ceph_version'] = self.version
+ osds['num_osds'] = self.osd_count
+
+ return {
+ "osd": osds,
+ "jrnl": OSDs._dump_devs(self.jrnl)
+ }
+
+ def get_stats(self):
+
+ start = time.time()
+
+ self._dev_to_osd()
+ self._stats_lookup()
+
+ end = time.time()
+
+ self.logger.info("osd get_stats call "
+ ": {:.3f}s".format((end - start)))
+
+ return self.dump()
--- /dev/null
+#!/usr/bin/env python
+
+import time
+
+from collectors.base import BaseCollector
+from collectors.common import get_hostname, merge_dicts
+
+
+class RGW(BaseCollector):
+
+ simple_metrics = {
+ "req": ("requests", "derive"),
+ "failed_req": ("requests_failed", "derive"),
+ "get": ("gets", "derive"),
+ "get_b": ("get_bytes", "derive"),
+ "put": ("puts", "derive"),
+ "put_b": ("put_bytes", "derive"),
+ "qlen": ("qlen", "derive"),
+ "qactive": ("requests_active", "derive")
+ }
+
+ int_latencies = [
+ "get_initial_lat",
+ "put_initial_lat"
+ ]
+
+ latencies = {
+ "get_initial_lat_sum": ("get_initial_lat_sum", "derive"),
+ "get_initial_lat_avgcount": ("get_initial_lat_avgcount", "derive"),
+ "put_initial_lat_sum": ("put_initial_lat_sum", "derive"),
+ "put_initial_lat_avgcount": ("put_initial_lat_avgcount", "derive")
+ }
+
+ all_metrics = merge_dicts(simple_metrics, latencies)
+
+ def __init__(self, *args, **kwargs):
+ BaseCollector.__init__(self, *args, **kwargs)
+ self.host_name = get_hostname()
+
+ def _get_rgw_data(self):
+
+ response = self._admin_socket()
+
+ key_name = 'client.rgw.{}'.format(self.host_name)
+
+ return response.get(key_name)
+
+ def _filter(self, stats):
+ # pick out the simple metrics
+
+ filtered = {key: stats[key] for key in RGW.simple_metrics}
+
+ for key in RGW.int_latencies:
+ for _attr in stats[key]:
+ new_key = "{}_{}".format(key, _attr)
+ filtered[new_key] = stats[key].get(_attr)
+
+ return filtered
+
+ def get_stats(self):
+
+ start = time.time()
+
+ raw_stats = self._get_rgw_data()
+
+ stats = self._filter(raw_stats)
+
+ stats['ceph_version'] = self.version
+
+ end = time.time()
+
+ self.logger.info("RGW get_stats : {:.3f}s".format((end - start)))
+
+ return {
+ "rgw": stats
+ }
--- /dev/null
+#!/usr/bin/env python2
+
+import os
+import sys
+import logging
+import json
+import yaml
+from requests import get, post, put
+import argparse
+import socket
+
+__author__ = 'Paul Cuzner'
+__version__ = '2.0'
+
+HEADERS = {"Accept": "application/json",
+ "Content-Type": "application/json"
+ }
+
+# variables that need to be updated for the local environment must be defined
+# to grafana as 'custom', for the updater to work
+
+
+class Config(object):
+ pass
+
+
+class DashBoardException(Exception):
+ pass
+
+
+def get_options():
+ """
+ Process runtime options
+
+ """
+ # Set up the runtime overrides
+ parser = argparse.ArgumentParser(prog='dashmgr',
+ description='Manage Ceph Monitoring '
+ 'dashboards in Grafana')
+ parser.add_argument('-c', '--config-file', type=str,
+ help='path of the config file to use',
+ default=os.path.join(os.getcwd(), 'dashboard.yml'))
+ parser.add_argument('-D', '--dashboard-dir', type=str,
+ help='path to the directory containing dashboards',
+ default=os.path.join(
+ os.getcwd(), 'dashboards/current'))
+ parser.add_argument('-m', '--mode', type=str,
+ help='run mode',
+ choices=['update', 'refresh'],
+ default='update')
+ parser.add_argument('-d', '--debug', action='store_true',
+ default=False,
+ help='run with additional debug')
+ parser.add_argument('-v', '--version', action='version',
+ version='%(prog)s - {}'.format(__version__))
+
+ return parser.parse_args()
+
+
+def fread(file_name=None):
+ with open(file_name) as f:
+ f_data = f.read()
+ return f_data
+
+
+def port_open(port, host='localhost'):
+ """
+ Check a given port is accessible
+ :param port: (int) port number to check
+ :param host: (str)hostname to check, default is localhost
+ :return: (bool) true if the port is accessible
+ """
+ socket.setdefaulttimeout(1)
+
+ sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ try:
+ sock.connect_ex((host, port))
+ sock.shutdown(socket.SHUT_RDWR)
+ sock.close()
+ return True
+ except socket.error:
+ return False
+
+
+def get_config(file_name):
+ """
+ read a given file, and attempt to load as yaml
+ :return (Config) config object instance
+ """
+ if os.path.exists(file_name):
+ config_data = fread(file_name)
+ try:
+ yaml_config = yaml.load(config_data)
+ except:
+ return None
+ else:
+ cfg = Config()
+ cfg.grafana_host = yaml_config.get('_grafana_host', 'localhost')
+ cfg.dashboards = yaml_config.get('_dashboards', [])
+ cfg.auth = yaml_config.get('_credentials', {"user": 'admin',
+ "password": "admin"})
+ cfg.grafana_credentials = (cfg.auth.get('user'),
+ cfg.auth.get('password'))
+ cfg.grafana_port = yaml_config.get('_grafana_port', 3000)
+ cfg.home_dashboard = yaml_config.get('_home_dashboard',
+ 'ceph-at-a-glance')
+ cfg.alert_dashboard = yaml_config.get('_alert_dashboard',
+ 'alert-status')
+ cfg.domain = yaml_config.get('domain', '')
+ cfg.yaml = yaml_config
+ return cfg
+
+ else:
+ return None
+
+
+def update_dashboard(dashboard_json, vars_to_update):
+ updates_made = 0
+ templating = dashboard_json['dashboard'].get('templating')
+ template_names = []
+ for l in templating.get('list'):
+ template_name = l.get('name')
+ if template_name in vars_to_update:
+
+ logger.debug("\tprocessing variable '{}'".format(template_name))
+ logger.debug("\tbefore")
+ logger.debug("\t{}".format(l))
+ template_names.append(template_name)
+ replacement_vars = vars_to_update.get(template_name)
+
+ if isinstance(replacement_vars, str):
+ replacement_vars = [replacement_vars]
+
+ l['query'] = ','.join(replacement_vars)
+ num_new_items = len(replacement_vars)
+ if num_new_items == 1:
+ l['current'] = {"text": replacement_vars[0],
+ "value": replacement_vars[0]}
+ l['options'] = [{"text": replacement_vars[0],
+ "selected": True,
+ "value": replacement_vars[0]}]
+ else:
+ l['current'] = {"text": "All",
+ "selected": True,
+ "value": "$__all"}
+ l['options'] = [{"text": "All",
+ "selected": True,
+ "value": "$__all"}]
+ for item in replacement_vars:
+ l['options'].append({"text": item,
+ "selected": False,
+ "value": item})
+
+ logger.debug("\tafter")
+ logger.debug("\t{}".format(l))
+ updates_made += 1
+
+ logger.info("- {} templating variables updated "
+ ": {}".format(updates_made,
+ ','.join(template_names)))
+ return dashboard_json
+
+
+def load_dashboard(dashboard_dir, dashboard_name):
+
+ sample_dashboard = os.path.join(dashboard_dir,
+ "{}.json".format(dashboard_name))
+ if os.path.exists(sample_dashboard):
+ # load it in
+ dashboard_data = fread(sample_dashboard)
+
+ # if domain has not been given, we need to remove it from the queries
+ if not config.domain:
+ dashboard_data = dashboard_data.replace('$domain.', '')
+
+ try:
+ dashjson = json.loads(dashboard_data)
+ except:
+ raise DashBoardException("Invalid json in {} "
+ "dashboard".format(dashboard_name))
+ else:
+ logger.debug("- {} sample loaded from {}".format(dashboard_name,
+ dashboard_dir))
+ del dashjson['meta']
+ dashjson['overwrite'] = True
+
+ # 'id' must be null for this to be a create, if it is anything
+ # else grafana will attempt an update, which will fail
+ # with a 404
+ dashjson['dashboard']['id'] = None
+ return dashjson
+ else:
+ logger.warning("- sample not available for {}, "
+ "skipping".format(dashboard_name))
+ return {}
+
+
+def get_dashboard(dashboard_name):
+
+ resp = get("http://{}:{}/api/dashboards/"
+ "db/{}".format(config.grafana_host,
+ config.grafana_port,
+ dashboard_name),
+ auth=config.grafana_credentials)
+
+ if resp.status_code == 404:
+ logger.info("- dashboard not found in Grafana")
+ return resp.status_code, {}
+
+ elif resp.status_code == 200:
+ logger.debug("- fetch of {} from Grafana "
+ "successful".format(dashboard_name))
+ return resp.status_code, resp.json()
+ else:
+ raise DashBoardException("Unknown problem fetching dashboard")
+
+
+def put_dashboard(dashjson):
+ upload_str = json.dumps(dashjson)
+ resp = post("http://{}:{}/api/dashboards/"
+ "db".format(config.grafana_host,
+ config.grafana_port),
+ headers=HEADERS,
+ auth=config.grafana_credentials,
+ data=upload_str)
+
+ return resp.status_code
+
+
+def star_dashboard(dashboard_id):
+
+ resp = post('http://{}:{}/api/user/stars/'
+ 'dashboard/{}'.format(config.grafana_host,
+ config.grafana_port,
+ dashboard_id),
+ headers=HEADERS,
+ auth=config.grafana_credentials)
+
+ if resp.status_code == 200:
+ logger.debug("- dashboard starred successfully")
+ else:
+ logger.warning("- starring dashboard with id {} "
+ "failed : {}".format(dashboard_id,
+ resp.status_code))
+ return resp.status_code
+
+def set_home_dashboard(home_dashboard):
+ # Ideally we should just check the json returned from an org query...but
+ # 4.3 of grafana doesn't return the home dashboard or theme settings!
+
+ logger.debug("- checking '{}' is starred".format(home_dashboard))
+
+ http_rc, dashjson = get_dashboard(home_dashboard)
+ if http_rc == 200 and dashjson:
+
+ dash_id = dashjson.get('dashboard').get('id')
+ is_starred = dashjson.get('meta').get('isStarred')
+ if not is_starred:
+ # star it
+ http_rc = star_dashboard(dash_id)
+ is_starred = True if http_rc == 200 else False
+
+ if is_starred:
+ # update the org's home dashboard
+ resp = put('http://{}:{}/api/org/'
+ 'preferences'.format(config.grafana_host,
+ config.grafana_port),
+ headers=HEADERS,
+ auth=config.grafana_credentials,
+ data=json.dumps({"name": "Main Org.",
+ "theme": "light",
+ "homeDashboardId": dash_id}))
+
+ if resp.status_code == 200:
+ logger.info("- setting home dashboard complete")
+ else:
+ logger.error("- setting home dashboard failed")
+
+ return resp.status_code
+
+ else:
+ logger.error("- unable to access dashboard {}".format(home_dashboard))
+
+ return http_rc
+
+
+def setup_logging():
+
+ logger = logging.getLogger('dashUpdater')
+ logger.setLevel(logging.DEBUG)
+
+ stream_handler = logging.StreamHandler(stream=sys.stdout)
+ if opts.debug:
+ stream_handler.setLevel(logging.DEBUG)
+ else:
+ stream_handler.setLevel(logging.INFO)
+
+ logger.addHandler(stream_handler)
+
+ return logger
+
+
+def get_notification_id(channel_name):
+ """
+ Check whether the given notification channel has been defined to Grafana
+ :param (str) notification channel name
+ :return: (int) id of the channel, or 0 for doesn't exist
+ """
+
+ resp = get("http://{}:{}/api/"
+ "alert-notifications".format(config.grafana_host,
+ config.grafana_port),
+ auth=config.grafana_credentials)
+
+ if resp.status_code == 200:
+ notifications = resp.json() # list if dicts returned by Grafana
+
+ # convert the list into a dict for lookup purposes
+ channels = {channel.get('name'): channel.get('id')
+ for channel in notifications}
+ if channel_name in channels:
+ return channels[channel_name]
+ else:
+ return 0
+ else:
+ raise DashBoardException("Unable to get nofification channels from"
+ " Grafana")
+
+
+def define_notification(channel_name):
+ """
+ Add a given "seed" notification channel to Grafana using http post
+ :param channel_name: (str) channel name
+ :return: (int) http response code from post operation
+ (dict) response json object
+ """
+
+ seed_channel = json.dumps({"name": channel_name,
+ "type": "email",
+ "isDefault": False
+ })
+
+ resp = post('http://{}:{}/api/'
+ 'alert-notifications'.format(config.grafana_host,
+ config.grafana_port),
+ headers=HEADERS,
+ auth=config.grafana_credentials,
+ data=seed_channel)
+
+ return resp.status_code, resp.json()
+
+
+def main():
+
+ rc = 0
+
+ if port_open(config.grafana_port, config.grafana_host):
+ logger.debug("Connection to Grafana is ok")
+ else:
+ logger.error("Unable to contact Grafana - does the config file "
+ "specify a valid host/ip address for Grafana?")
+ return 16
+
+ if config.dashboards:
+ vars_to_update = {k: config.yaml[k] for k in config.yaml
+ if not k.startswith('_')}
+ if 'domain' not in vars_to_update:
+ vars_to_update['domain'] = config.domain
+
+ else:
+ logger.error("Config file doesn't contain dashboards! Unable "
+ "to continue")
+ return 16
+
+ dashboards_updated = 0
+ logger.debug("Templates to update: {}".format(vars_to_update))
+
+ for dashname in config.dashboards:
+ logger.info("\nProcessing dashboard {}".format(dashname))
+
+ http_rc, dashjson = get_dashboard(dashname)
+ if dashname == config.alert_dashboard and http_rc == 200:
+ logger.info("- existing alert dashboard found, update bypassed")
+ continue
+
+ if opts.mode == 'update':
+
+ if http_rc == 200:
+ # the dashboard is already loaded, so we'll use the existing
+ # definition
+ logger.debug("- existing dashboard will be updated")
+ else:
+ # get of dashboard failed, so just load it
+ dashjson = load_dashboard(opts.dashboard_dir, dashname)
+
+ if dashjson:
+ logger.info("- dashboard loaded from sample")
+ else:
+ logger.warning("- sample not available, skipping")
+ rc = max(rc, 4)
+ continue
+
+ logger.info("- dashboard retrieved")
+
+ elif opts.mode == 'refresh':
+
+ dashjson = load_dashboard(opts.dashboard_dir, dashname)
+
+ if not dashjson:
+ logger.warning("- sample not available, skipping")
+ rc = max(rc, 4)
+ continue
+
+ if dashname == config.alert_dashboard:
+ # if processing is here, this is 1st run so the alert_dashboard
+ # is new to grafana
+ channel_id = get_notification_id("cephmetrics")
+ if channel_id:
+ logger.info("- notification channel already in place")
+ else:
+ http_rc, resp_json = define_notification("cephmetrics")
+ if http_rc == 200:
+ channel_id = resp_json['id']
+ logger.info("- notification channel added :"
+ "{}".format(channel_id))
+ else:
+ raise DashBoardException("Problem adding notification "
+ "channel ({})".format(http_rc))
+
+ dash_str = json.dumps(dashjson)
+ dash_str = dash_str.replace('"notifications": []',
+ '"notifications": [{{ "id":'
+ ' {0} }}]'.format(channel_id))
+ if config.domain:
+ logger.debug("- queries updated, replacing $domain with "
+ "'{}'".format(config.domain))
+ dash_str = dash_str.replace('.$domain',
+ ".{}".format(config.domain))
+ else:
+ logger.debug("- queries updated, replacing $domain with NULL")
+ dash_str = dash_str.replace('.$domain',
+ '')
+
+ dashjson = json.loads(dash_str)
+
+ else:
+ # Normal dashboard processing
+ templating = dashjson['dashboard'].get('templating')
+ if templating:
+ dashjson = update_dashboard(dashjson, vars_to_update)
+ else:
+ logger.info('- templating not defined in {}, '
+ 'skipping'.format(dashname))
+ rc = max(rc, 4)
+
+ http_rc = put_dashboard(dashjson)
+
+ if http_rc == 200:
+ logger.info("- dashboard update successful")
+ dashboards_updated += 1
+
+ if dashname == config.home_dashboard:
+ # ensure the home dashboard is defined
+ http_rc = set_home_dashboard(dashname)
+
+ if http_rc != 200:
+ logger.warning("- Unable to set the home dashboard")
+ rc = max(rc, 12)
+
+ else:
+ logger.error("- dashboard {} update failed ({})".format(dashname,
+ http_rc))
+ rc = max(rc, 8)
+
+ return rc
+
+
+if __name__ == '__main__':
+
+ opts = get_options()
+
+ config = get_config(opts.config_file)
+
+ if config:
+
+ logger = setup_logging()
+
+ rc = main()
+
+ sys.exit(rc)
+
+ else:
+
+ print("Invalid config file detected, unable to start")
+ sys.exit(16)
--- /dev/null
+---
+##########################################################
+# Change these settings to reflect your ceph environment #
+##########################################################
+osd_servers:
+ - obj-osd-1
+ - obj-osd-2
+ - obj-osd-3
+
+rgw_servers:
+ - obj-rgw-1
+
+#iscsi_gateways:
+# - rh7-gw1
+# - rh7-gw2
+
+domain: storage.lab
+
+###########################################################################
+# This section defines the internal variables (denoted by the '_' prefix) #
+# that govern how dashUpdater.py runs. Normally you'd leave these alone #
+###########################################################################
+_dashboards:
+ - alert-status
+ - ceph-at-a-glance
+ - ceph-backend-storage
+ - ceph-cluster
+ - ceph-health
+ - ceph-osd-information
+ - ceph-pools
+ - ceph-rgw-workload
+ - disk-busy-by-server
+ - iops-by-server
+ - iscsi-overview
+ - latency-by-server
+ - network-usage-by-node
+ - osd-node-detail
+
+_home_dashboard: ceph-at-a-glance
+_alert_dashboard: alert-status
+
+_credentials:
+ user: admin@localhost
+ password: admin
+
+_grafana_port: 3000
+
--- /dev/null
+{
+ "__inputs": [
+ {
+ "name": "DS_INFLUX",
+ "label": "influx",
+ "description": "",
+ "type": "datasource",
+ "pluginId": "influxdb",
+ "pluginName": "InfluxDB"
+ }
+ ],
+ "__requires": [
+ {
+ "type": "grafana",
+ "id": "grafana",
+ "name": "Grafana",
+ "version": "4.2.0"
+ },
+ {
+ "type": "panel",
+ "id": "graph",
+ "name": "Graph",
+ "version": ""
+ },
+ {
+ "type": "datasource",
+ "id": "influxdb",
+ "name": "InfluxDB",
+ "version": "1.0.0"
+ },
+ {
+ "type": "panel",
+ "id": "singlestat",
+ "name": "Singlestat",
+ "version": ""
+ }
+ ],
+ "annotations": {
+ "list": []
+ },
+ "editable": true,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": false,
+ "id": null,
+ "links": [],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": 157,
+ "panels": [
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_INFLUX}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 1,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 3,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_mon",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": "",
+ "title": "Monitors",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_INFLUX}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 2,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 3,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_osd",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": "",
+ "title": "OSDs",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_INFLUX}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 7,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 3,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.recovering_bytes_per_sec",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": "",
+ "title": "Recovery Workload",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "datasource": "${DS_INFLUX}",
+ "format": "bytes",
+ "gauge": {
+ "maxValue": 50465865728,
+ "minValue": 0,
+ "show": true,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 8,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 3,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.osd_bytes_used",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": "35949672960,42949672960",
+ "title": "Capacity Used",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Overview",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_INFLUX}",
+ "fill": 1,
+ "id": 4,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 6,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "reads",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "writes",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.write_op_per_sec\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Client IOPS for all Pools",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_INFLUX}",
+ "fill": 1,
+ "id": 6,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 6,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "Reads",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.read_bytes_sec",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "Writes",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.read_bytes_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.write_bytes_sec\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Client Throughput - All Pools",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Pool Overview",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_INFLUX}",
+ "fill": 1,
+ "id": 3,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 12,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "Raw Capacity",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.osd_bytes",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "Used",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.osd_bytes_used",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Cluster Capacity",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": false,
+ "title": "Dashboard Row",
+ "titleSize": "h6"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [],
+ "templating": {
+ "list": []
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "Ceph Dashboard",
+ "version": 2
+}
\ No newline at end of file
--- /dev/null
+{
+ "__inputs": [
+ {
+ "name": "DS_INFLUX",
+ "label": "influx",
+ "description": "",
+ "type": "datasource",
+ "pluginId": "influxdb",
+ "pluginName": "InfluxDB"
+ },
+ {
+ "name": "VAR_MONITOR",
+ "type": "constant",
+ "label": "monitor",
+ "value": "obj-mon-1.storage.lab",
+ "description": ""
+ },
+ {
+ "name": "VAR_CLUSTER_NAME",
+ "type": "constant",
+ "label": "cluster_name",
+ "value": "ceph",
+ "description": ""
+ }
+ ],
+ "__requires": [
+ {
+ "type": "grafana",
+ "id": "grafana",
+ "name": "Grafana",
+ "version": "4.2.0"
+ },
+ {
+ "type": "panel",
+ "id": "graph",
+ "name": "Graph",
+ "version": ""
+ },
+ {
+ "type": "datasource",
+ "id": "influxdb",
+ "name": "InfluxDB",
+ "version": "1.0.0"
+ },
+ {
+ "type": "panel",
+ "id": "singlestat",
+ "name": "Singlestat",
+ "version": ""
+ },
+ {
+ "type": "panel",
+ "id": "table",
+ "name": "Table",
+ "version": ""
+ },
+ {
+ "type": "panel",
+ "id": "vonage-status-panel",
+ "name": "Status Panel",
+ "version": "1.0.4"
+ }
+ ],
+ "annotations": {
+ "list": []
+ },
+ "editable": true,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": false,
+ "id": null,
+ "links": [],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": 226,
+ "panels": [
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_INFLUX}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 1,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_mon",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": "",
+ "title": "Monitors",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "clusterName": "OSDs",
+ "displayName": "OSDs",
+ "flipCard": false,
+ "flipTime": 5,
+ "id": 20,
+ "isGrayOnNoData": true,
+ "links": [],
+ "minSpan": 1,
+ "namePrefix": "",
+ "span": 1,
+ "targets": [
+ {
+ "aggregation": "Last",
+ "alias": "Total",
+ "displayType": "Annotation",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_osd",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "valueDisplayRegex": "/.*/",
+ "valueHandler": "Text Only"
+ },
+ {
+ "aggregation": "Last",
+ "alias": "Up",
+ "display": true,
+ "displayType": "Regular",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_osd_up",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "valueDisplayRegex": "/.*/",
+ "valueHandler": "Text Only"
+ },
+ {
+ "aggregation": "Last",
+ "alias": "In",
+ "displayType": "Regular",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_osd_up",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_osd_up\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "valueDisplayRegex": "/.*/",
+ "valueHandler": "Text Only"
+ }
+ ],
+ "title": "",
+ "type": "vonage-status-panel"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_INFLUX}",
+ "format": "bytes",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 7,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(193, 106, 31)",
+ "show": true
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.recovering_bytes_per_sec",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": "",
+ "title": "Recovery Workload",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_INFLUX}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 9,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": true
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": false,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM \"measurement\" WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": false,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.write_op_per_sec\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": "",
+ "title": "Client IOPS",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_INFLUX}",
+ "decimals": null,
+ "format": "bytes",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 23,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": true
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": false,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.read_bytes_sec\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.write_op_per_sec\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": "",
+ "title": "Client Bandwidth",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 16,
+ "links": [],
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": false
+ },
+ "span": 2,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": "value",
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [
+ "1",
+ "50"
+ ],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "alias": "PG's peering",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_pg_peering",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_pg_peering\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "Object Degraded",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_object_degraded",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_object_degraded\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "Objects Unfound",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_object_unfound",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_object_unfound\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "Objects Recovering",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.recovering_objects_per_sec",
+ "policy": "default",
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "title": "Health Indicators",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "datasource": "${DS_INFLUX}",
+ "format": "bytes",
+ "gauge": {
+ "maxValue": 50465865728,
+ "minValue": 0,
+ "show": true,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 8,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.osd_bytes_used",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": "35949672960,42949672960",
+ "title": "Capacity Used",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Overview",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 256,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_INFLUX}",
+ "fill": 1,
+ "id": 3,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 7,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "Raw Capacity",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.osd_bytes",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "Used",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.osd_bytes_used",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Cluster Capacity",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_INFLUX}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 17,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_pool",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": "",
+ "title": "Pools",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 18,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": true
+ },
+ "span": 2,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "alias": "OSDs",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_osd",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "OSD's Active (in)",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_osd_in",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "OSD's Up",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_osd_in",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_osd_up\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "title": "OSD State",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Cluster Capacity",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": false,
+ "height": 238,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_INFLUX}",
+ "fill": 1,
+ "id": 11,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.$monitor.cephmetrics.gauge.$cluster_name.pools.$pool_name.read_op_per_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.$monitor.cephmetrics.gauge.$cluster_name.pools.$pool_name.write_op_per_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Client Workload IOPS (pools: $pool_name)",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "IOPS",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_INFLUX}",
+ "fill": 1,
+ "id": 21,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools.$pool_name.read_bytes_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.$monitor.cephmetrics.gauge.$cluster_name.pools.$pool_name.write_bytes_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Client Workload Throughput (pools: $pool_name)",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": "Bandwidth",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_INFLUX}",
+ "fill": 1,
+ "id": 22,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.$monitor.cephmetrics.gauge.$cluster_name.pools.$pool_name.recovering_bytes_per_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Recovery Overhead (pools: $pool_name)",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": "Bandwidth",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Workload by Pool",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": false,
+ "height": 223,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_INFLUX}",
+ "fill": 1,
+ "id": 19,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 3,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 3,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "PUT",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.put_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Request Latency",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "s",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_INFLUX}",
+ "fill": 1,
+ "id": 25,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 3,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 3,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.get",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.derive.ceph.rgw.get$/ WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "PUT",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.get",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.derive.ceph.rgw.put$/ WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Requests/sec",
+ "tooltip": {
+ "shared": true,
+ "sort": 1,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_INFLUX}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "",
+ "id": 26,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.qlen",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "thresholds": "",
+ "title": "Queue",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "RGW Host (S3/Swift)",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "datasource": "${DS_INFLUX}",
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 10,
+ "links": [],
+ "minSpan": 3,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": null,
+ "desc": false
+ },
+ "span": 3,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "none"
+ }
+ ],
+ "targets": [
+ {
+ "alias": "Objects",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_object",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "Degraded",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_object_degraded",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "Misplaced",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_object_misplaced",
+ "policy": "default",
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "UnFound",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_object_unfound",
+ "policy": "default",
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "title": "Object Summary",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "datasource": "${DS_INFLUX}",
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 13,
+ "links": [],
+ "minSpan": 3,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": null,
+ "desc": false
+ },
+ "span": 3,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "none"
+ }
+ ],
+ "targets": [
+ {
+ "alias": "PG's",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_pg",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "Active",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_pg_active",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "Active/Clean",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_pg_active_clean",
+ "policy": "default",
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": []
+ },
+ {
+ "alias": "Peering",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.cluster.num_pg_peering",
+ "policy": "default",
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": []
+ }
+ ],
+ "title": "PG Summary",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "RADOS",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_INFLUX}",
+ "fill": 1,
+ "id": 24,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 12,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {}
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Panel Title",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "OSD Breakdown",
+ "titleSize": "h6"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [],
+ "templating": {
+ "list": [
+ {
+ "current": {
+ "value": "${VAR_MONITOR}",
+ "text": "${VAR_MONITOR}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "monitor",
+ "options": [
+ {
+ "value": "${VAR_MONITOR}",
+ "text": "${VAR_MONITOR}"
+ }
+ ],
+ "query": "${VAR_MONITOR}",
+ "type": "constant"
+ },
+ {
+ "current": {
+ "value": "${VAR_CLUSTER_NAME}",
+ "text": "${VAR_CLUSTER_NAME}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "cluster_name",
+ "options": [
+ {
+ "value": "${VAR_CLUSTER_NAME}",
+ "text": "${VAR_CLUSTER_NAME}"
+ }
+ ],
+ "query": "${VAR_CLUSTER_NAME}",
+ "type": "constant"
+ },
+ {
+ "allValue": null,
+ "current": {},
+ "datasource": "${DS_INFLUX}",
+ "hide": 0,
+ "includeAll": false,
+ "label": "Pool Name",
+ "multi": false,
+ "name": "pool_name",
+ "options": [],
+ "query": "show series ",
+ "refresh": 1,
+ "regex": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.pools\\.(\\w+)/",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {},
+ "datasource": "${DS_INFLUX}",
+ "hide": 0,
+ "includeAll": false,
+ "label": "RGW Host",
+ "multi": false,
+ "name": "rgw_name",
+ "options": [],
+ "query": "show series",
+ "refresh": 1,
+ "regex": "/collectd\\.(.*)\\.cephmetrics.*\\.rgw/",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ }
+ ]
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "Ceph Dashboard",
+ "version": 57
+}
\ No newline at end of file
--- /dev/null
+{
+ "__inputs": [
+ {
+ "name": "DS_LOCAL",
+ "label": "Local",
+ "description": "",
+ "type": "datasource",
+ "pluginId": "graphite",
+ "pluginName": "Graphite"
+ },
+ {
+ "name": "VAR_MONITOR",
+ "type": "constant",
+ "label": "monitor",
+ "value": "obj-mon-1.storage.lab",
+ "description": ""
+ },
+ {
+ "name": "VAR_CLUSTER_NAME",
+ "type": "constant",
+ "label": "cluster_name",
+ "value": "ceph",
+ "description": ""
+ },
+ {
+ "name": "VAR_RGW_NAME",
+ "type": "constant",
+ "label": "RGW Host",
+ "value": "obj-rgw-1",
+ "description": ""
+ },
+ {
+ "name": "VAR_DOMAIN",
+ "type": "constant",
+ "label": "domain",
+ "value": "storage.lab",
+ "description": ""
+ }
+ ],
+ "__requires": [
+ {
+ "type": "grafana",
+ "id": "grafana",
+ "name": "Grafana",
+ "version": "4.2.0"
+ },
+ {
+ "type": "panel",
+ "id": "graph",
+ "name": "Graph",
+ "version": ""
+ },
+ {
+ "type": "datasource",
+ "id": "graphite",
+ "name": "Graphite",
+ "version": "1.0.0"
+ },
+ {
+ "type": "panel",
+ "id": "singlestat",
+ "name": "Singlestat",
+ "version": ""
+ },
+ {
+ "type": "panel",
+ "id": "table",
+ "name": "Table",
+ "version": ""
+ }
+ ],
+ "annotations": {
+ "list": []
+ },
+ "editable": true,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": false,
+ "id": null,
+ "links": [],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": 243,
+ "panels": [
+ {
+ "cacheTimeout": null,
+ "colorBackground": true,
+ "colorValue": false,
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 28,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "refId": "A",
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.health"
+ }
+ ],
+ "thresholds": "1",
+ "title": "Health",
+ "type": "singlestat",
+ "valueFontSize": "100%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "OK",
+ "value": "0"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 1,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_mon",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_mon\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_mon",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "Monitors",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 27,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "refId": "A",
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_osd"
+ }
+ ],
+ "thresholds": "",
+ "title": "OSDs",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "bytes",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 7,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(193, 106, 31)",
+ "show": true
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.recovering_bytes_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.recovering_bytes_per_sec\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.recovering_bytes_per_sec",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "Recovery Workload",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 9,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": true
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM \"measurement\" WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": false,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.read_op_per_sec"
+ },
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM \"measurement\" WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": false,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.write_op_per_sec"
+ },
+ {
+ "refId": "C",
+ "target": "sumSeries(#A, #B).select metric",
+ "targetFull": "sumSeries(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.read_op_per_sec, collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.write_op_per_sec).select metric"
+ }
+ ],
+ "thresholds": "",
+ "title": "Client IOPS",
+ "type": "singlestat",
+ "valueFontSize": "100%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "decimals": 1,
+ "format": "bytes",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 23,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": true
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_bytes_sec\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.read_bytes_sec"
+ },
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_bytes_sec\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.pools._all_.write_bytes_sec"
+ },
+ {
+ "refId": "C",
+ "target": "sumSeries(#A,#B).select metric",
+ "targetFull": "sumSeries(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.read_bytes_sec,collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.write_bytes_sec).select metric"
+ }
+ ],
+ "thresholds": "",
+ "title": "Client Bandwidth",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "decimals": 1,
+ "format": "bytes",
+ "gauge": {
+ "maxValue": 50465865728,
+ "minValue": 0,
+ "show": true,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 8,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.osd_bytes_used",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used"
+ }
+ ],
+ "thresholds": "35949672960,42949672960",
+ "title": "Capacity Used",
+ "type": "singlestat",
+ "valueFontSize": "50%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Overview",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 256,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 3,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 7,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "Raw Capacity",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.osd_bytes",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.osd_bytes, 'Raw')"
+ },
+ {
+ "alias": "Used",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.osd_bytes_used",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used, 'Used')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Cluster Capacity",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 17,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pool",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pool"
+ }
+ ],
+ "thresholds": "",
+ "title": "Pools",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 18,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": true
+ },
+ "span": 2,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "alias": "OSD's Up",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_in",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_up\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_osd, 'OSDs')"
+ },
+ {
+ "alias": "OSD's Up",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_in",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_up\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_osd_in, 'OSDs In')"
+ },
+ {
+ "alias": "OSD's Up",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_in",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_up\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_osd_up, 'OSDs Up')"
+ }
+ ],
+ "title": "OSD State",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Cluster Capacity",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 238,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 11,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec, 'Reads')"
+ },
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec, 'Writes')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Client Workload IOPS (pools: $pool_name)",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "IOPS",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 21,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_bytes_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec, 'Read')"
+ },
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_bytes_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec, 'Write')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Client Workload Throughput (pools: $pool_name)",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": "Bandwidth",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.recovering_bytes_per_sec": "#C15C17"
+ },
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 22,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.recovering_bytes_per_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.recovering_bytes_per_sec"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Recovery Overhead (pools: $pool_name)",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": "Bandwidth",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Workload by Pool",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 302,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 19,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 5,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 5,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_avgcount"
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_sum"
+ },
+ {
+ "refId": "C",
+ "target": "alias(divideSeries(#B, #A),\"GET\")",
+ "targetFull": "divideSeries(collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_sum, collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_avgcount).select metric",
+ "textEditor": true
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_avgcount"
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "E",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_sum"
+ },
+ {
+ "refId": "F",
+ "target": "alias(divideSeries(#E,#D), \"PUT\")",
+ "targetFull": "divideSeries(collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_sum,collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_avgcount).select metric",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Request Latency",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "s",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 25,
+ "legend": {
+ "alignAsTable": false,
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "rightSide": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 5,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 5,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.get",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.derive.ceph.rgw.get$/ WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get, 'GET')"
+ },
+ {
+ "alias": "PUT",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.get",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.derive.ceph.rgw.put$/ WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put, 'PUT')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Requests/sec",
+ "tooltip": {
+ "shared": true,
+ "sort": 1,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "",
+ "id": 26,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.qlen",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.qlen"
+ }
+ ],
+ "thresholds": "",
+ "title": "Queue",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "RGW Host (S3/Swift)",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "datasource": "${DS_LOCAL}",
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 10,
+ "links": [],
+ "minSpan": 3,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": null,
+ "desc": false
+ },
+ "span": 3,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "none"
+ }
+ ],
+ "targets": [
+ {
+ "alias": "Objects",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object, 'Objects')"
+ },
+ {
+ "alias": "Objects",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object_degraded, 'Objects degraded')"
+ },
+ {
+ "alias": "Objects",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy": "default",
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object_misplaced, 'Objects misplaced')"
+ },
+ {
+ "alias": "Objects",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy": "default",
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object_unfound, 'Objects unfound')"
+ }
+ ],
+ "title": "Object Summary",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "datasource": "${DS_LOCAL}",
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 13,
+ "links": [],
+ "minSpan": 3,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": null,
+ "desc": false
+ },
+ "span": 3,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "none"
+ }
+ ],
+ "targets": [
+ {
+ "alias": "PG's",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pg, 'PGs')"
+ },
+ {
+ "alias": "PG's",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pg_active, 'Active PGs')"
+ },
+ {
+ "alias": "PG's",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy": "default",
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pg_active_clean, 'Active+clean PGs')"
+ },
+ {
+ "alias": "PG's",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy": "default",
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pg_peering, 'PGs peering')"
+ }
+ ],
+ "title": "PG Summary",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "RADOS",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 24,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 12,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {}
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Panel Title",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "OSD Breakdown",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "filterNull": false,
+ "fontSize": "100%",
+ "height": "245px",
+ "id": 16,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": false
+ },
+ "span": 12,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": "value",
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [
+ "1",
+ "50"
+ ],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "alias": "PG's peering",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg_peering",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg_peering\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object_degraded, 'Objects degraded')",
+ "textEditor": false
+ },
+ {
+ "alias": "Object Degraded",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object_degraded",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object_degraded\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pg_peering, 'PGs peering')"
+ },
+ {
+ "alias": "Objects Unfound",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object_unfound",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object_unfound\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object_unfound, 'Objects unfound')"
+ },
+ {
+ "alias": "Objects Recovering",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.recovering_objects_per_sec",
+ "policy": "default",
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.recovering_objects_per_sec, 'Objects recovering')"
+ }
+ ],
+ "title": "Health Indicators",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": false,
+ "title": "Dashboard Row",
+ "titleSize": "h6"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [],
+ "templating": {
+ "list": [
+ {
+ "current": {
+ "value": "${VAR_MONITOR}",
+ "text": "${VAR_MONITOR}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "monitor",
+ "options": [
+ {
+ "value": "${VAR_MONITOR}",
+ "text": "${VAR_MONITOR}"
+ }
+ ],
+ "query": "${VAR_MONITOR}",
+ "type": "constant"
+ },
+ {
+ "current": {
+ "value": "${VAR_CLUSTER_NAME}",
+ "text": "${VAR_CLUSTER_NAME}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "cluster_name",
+ "options": [
+ {
+ "value": "${VAR_CLUSTER_NAME}",
+ "text": "${VAR_CLUSTER_NAME}"
+ }
+ ],
+ "query": "${VAR_CLUSTER_NAME}",
+ "type": "constant"
+ },
+ {
+ "allValue": null,
+ "current": {},
+ "datasource": "${DS_LOCAL}",
+ "hide": 2,
+ "includeAll": false,
+ "label": "Pool Name",
+ "multi": false,
+ "name": "pool_name_old",
+ "options": [],
+ "query": "show series ",
+ "refresh": 1,
+ "regex": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools\\.(\\w+)/",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {},
+ "datasource": "${DS_LOCAL}",
+ "hide": 2,
+ "includeAll": false,
+ "label": "RGW Host",
+ "multi": false,
+ "name": "rgw_name_old",
+ "options": [],
+ "query": "show series",
+ "refresh": 1,
+ "regex": "/collectd\\.(.*)\\.cephmetrics.*\\.rgw/",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {},
+ "datasource": "${DS_LOCAL}",
+ "hide": 0,
+ "includeAll": false,
+ "label": "Pool Name",
+ "multi": false,
+ "name": "pool_name",
+ "options": [],
+ "query": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "current": {
+ "value": "${VAR_RGW_NAME}",
+ "text": "${VAR_RGW_NAME}"
+ },
+ "hide": 0,
+ "label": "RGW Host",
+ "name": "rgw_name",
+ "options": [
+ {
+ "value": "${VAR_RGW_NAME}",
+ "text": "${VAR_RGW_NAME}"
+ }
+ ],
+ "query": "${VAR_RGW_NAME}",
+ "type": "constant"
+ },
+ {
+ "current": {
+ "value": "${VAR_DOMAIN}",
+ "text": "${VAR_DOMAIN}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "domain",
+ "options": [
+ {
+ "value": "${VAR_DOMAIN}",
+ "text": "${VAR_DOMAIN}"
+ }
+ ],
+ "query": "${VAR_DOMAIN}",
+ "type": "constant"
+ }
+ ]
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "Ceph Dashboard (Graphite)",
+ "version": 1
+}
\ No newline at end of file
--- /dev/null
+{
+ "__inputs": [
+ {
+ "name": "DS_LOCAL",
+ "label": "Local",
+ "description": "",
+ "type": "datasource",
+ "pluginId": "graphite",
+ "pluginName": "Graphite"
+ },
+ {
+ "name": "VAR_MONITOR",
+ "type": "constant",
+ "label": "monitor",
+ "value": "obj-mon-1.storage.lab",
+ "description": ""
+ },
+ {
+ "name": "VAR_CLUSTER_NAME",
+ "type": "constant",
+ "label": "cluster_name",
+ "value": "ceph",
+ "description": ""
+ },
+ {
+ "name": "VAR_DOMAIN",
+ "type": "constant",
+ "label": "domain",
+ "value": "storage.lab",
+ "description": ""
+ }
+ ],
+ "__requires": [
+ {
+ "type": "grafana",
+ "id": "grafana",
+ "name": "Grafana",
+ "version": "4.2.0"
+ },
+ {
+ "type": "panel",
+ "id": "graph",
+ "name": "Graph",
+ "version": ""
+ },
+ {
+ "type": "datasource",
+ "id": "graphite",
+ "name": "Graphite",
+ "version": "1.0.0"
+ },
+ {
+ "type": "panel",
+ "id": "singlestat",
+ "name": "Singlestat",
+ "version": ""
+ },
+ {
+ "type": "panel",
+ "id": "table",
+ "name": "Table",
+ "version": ""
+ }
+ ],
+ "annotations": {
+ "list": []
+ },
+ "editable": true,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": false,
+ "id": null,
+ "links": [],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": 243,
+ "panels": [
+ {
+ "cacheTimeout": null,
+ "colorBackground": true,
+ "colorValue": false,
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 28,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "refId": "A",
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.health"
+ }
+ ],
+ "thresholds": "1",
+ "title": "Health",
+ "type": "singlestat",
+ "valueFontSize": "100%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "OK",
+ "value": "0"
+ },
+ {
+ "op": "=",
+ "text": "Warning",
+ "value": "4"
+ },
+ {
+ "op": "=",
+ "text": "Error",
+ "value": "8"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 1,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_mon",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_mon\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_mon",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "Monitors",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 27,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "refId": "A",
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_osd"
+ }
+ ],
+ "thresholds": "",
+ "title": "OSDs",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 33,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "refId": "A",
+ "target": "sumSeries(offset(scale(collectd.*.$domain.cephmetrics.derive.$cluster_name.rgw.put,0),1))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "RGW Hosts",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 34,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "refId": "A",
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_mds_in"
+ }
+ ],
+ "thresholds": "",
+ "title": "MDS",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "bytes",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 7,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(193, 106, 31)",
+ "show": true
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.recovering_bytes_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.recovering_bytes_per_sec\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.recovering_bytes_per_sec",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "Recovery",
+ "type": "singlestat",
+ "valueFontSize": "70%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 9,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": true
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM \"measurement\" WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": false,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.read_op_per_sec"
+ },
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM \"measurement\" WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": false,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.write_op_per_sec"
+ },
+ {
+ "refId": "C",
+ "target": "sumSeries(#A, #B).select metric",
+ "targetFull": "sumSeries(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.read_op_per_sec, collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.write_op_per_sec).select metric"
+ }
+ ],
+ "thresholds": "",
+ "title": "Client IOPS",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "decimals": 1,
+ "format": "bytes",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 23,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": true
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_bytes_sec\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.read_bytes_sec"
+ },
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_bytes_sec\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.pools._all_.write_bytes_sec"
+ },
+ {
+ "refId": "C",
+ "target": "sumSeries(#A,#B).select metric",
+ "targetFull": "sumSeries(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.read_bytes_sec,collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.write_bytes_sec).select metric"
+ }
+ ],
+ "thresholds": "",
+ "title": "Client Load",
+ "type": "singlestat",
+ "valueFontSize": "70%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "decimals": 1,
+ "format": "bytes",
+ "gauge": {
+ "maxValue": 50465865728,
+ "minValue": 0,
+ "show": true,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 8,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.osd_bytes_used",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used"
+ }
+ ],
+ "thresholds": "35949672960,42949672960",
+ "title": "Capacity Used",
+ "type": "singlestat",
+ "valueFontSize": "50%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Overview",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": false,
+ "height": 256,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 3,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 7,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "Raw Capacity",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.osd_bytes",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.osd_bytes, 'Raw')"
+ },
+ {
+ "alias": "Used",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.osd_bytes_used",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used, 'Used')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Cluster Capacity",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 17,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pool",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pool"
+ }
+ ],
+ "thresholds": "",
+ "title": "Pools",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 18,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": true
+ },
+ "span": 2,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "alias": "OSD's Up",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_in",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_up\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_osd, 'OSDs')"
+ },
+ {
+ "alias": "OSD's Up",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_in",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_up\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_osd_in, 'OSDs In')"
+ },
+ {
+ "alias": "OSD's Up",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_in",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_up\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_osd_up, 'OSDs Up')"
+ }
+ ],
+ "title": "OSD State",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Cluster Capacity",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": false,
+ "height": 238,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 11,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec, 'Reads')"
+ },
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec, 'Writes')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Client Workload IOPS (pools: $pool_name)",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "IOPS",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 21,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_bytes_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec, 'Read')"
+ },
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_bytes_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec, 'Write')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Client Workload Throughput (pools: $pool_name)",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": "Bandwidth",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.recovering_bytes_per_sec": "#C15C17"
+ },
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 22,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.recovering_bytes_per_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.recovering_bytes_per_sec"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Recovery Overhead (pools: $pool_name)",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": "Bandwidth",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Workload Detail by Pool",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": false,
+ "height": 302,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 19,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 5,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 3,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_avgcount"
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_sum"
+ },
+ {
+ "refId": "C",
+ "target": "alias(divideSeries(#B, #A),\"GET\")",
+ "targetFull": "divideSeries(collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_sum, collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_avgcount).select metric",
+ "textEditor": true
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_avgcount"
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "E",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_sum"
+ },
+ {
+ "refId": "F",
+ "target": "alias(divideSeries(#E,#D), \"PUT\")",
+ "targetFull": "divideSeries(collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_sum,collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_avgcount).select metric",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Request Latency",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "s",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 25,
+ "legend": {
+ "alignAsTable": false,
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "rightSide": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 5,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 3,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.get",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.derive.ceph.rgw.get$/ WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get, 'GET')"
+ },
+ {
+ "alias": "PUT",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.get",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.derive.ceph.rgw.put$/ WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put, 'PUT')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Requests/sec",
+ "tooltip": {
+ "shared": true,
+ "sort": 1,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "",
+ "id": 26,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.qlen",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.qlen"
+ }
+ ],
+ "thresholds": "",
+ "title": "Queue",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 32,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 2,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 2,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(scale(averageSeries(collectd.$rgw_name.$domain.cpu.*.cpu.idle),0.01), 1)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "CPU Busy",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "percent",
+ "label": "",
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 31,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 3,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 3,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(sumSeries(collectd.$rgw_name.$domain.interface.*.if_octets.rx), 'rx')"
+ },
+ {
+ "refId": "B",
+ "target": "alias(sumSeries(collectd.$rgw_name.$domain.interface.*.if_octets.tx), 'tx')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Network Load",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "Bps",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "RGW Host (S3/Swift)",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "datasource": "${DS_LOCAL}",
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 10,
+ "links": [],
+ "minSpan": 3,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": null,
+ "desc": false
+ },
+ "span": 3,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "none"
+ }
+ ],
+ "targets": [
+ {
+ "alias": "Objects",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object, 'Objects')"
+ },
+ {
+ "alias": "Objects",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object_degraded, 'Objects degraded')"
+ },
+ {
+ "alias": "Objects",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy": "default",
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object_misplaced, 'Objects misplaced')"
+ },
+ {
+ "alias": "Objects",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy": "default",
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object_unfound, 'Objects unfound')"
+ }
+ ],
+ "title": "Object Summary",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "datasource": "${DS_LOCAL}",
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 13,
+ "links": [],
+ "minSpan": 3,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": null,
+ "desc": false
+ },
+ "span": 3,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "none"
+ }
+ ],
+ "targets": [
+ {
+ "alias": "PG's",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pg, 'PGs')"
+ },
+ {
+ "alias": "PG's",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pg_active, 'Active PGs')"
+ },
+ {
+ "alias": "PG's",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy": "default",
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pg_active_clean, 'Active+clean PGs')"
+ },
+ {
+ "alias": "PG's",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy": "default",
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pg_peering, 'PGs peering')"
+ }
+ ],
+ "title": "PG Summary",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "RADOS",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 24,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 12,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {}
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Panel Title",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "OSD Breakdown",
+ "titleSize": "h6"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [],
+ "templating": {
+ "list": [
+ {
+ "current": {
+ "value": "${VAR_MONITOR}",
+ "text": "${VAR_MONITOR}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "monitor",
+ "options": [
+ {
+ "value": "${VAR_MONITOR}",
+ "text": "${VAR_MONITOR}"
+ }
+ ],
+ "query": "${VAR_MONITOR}",
+ "type": "constant"
+ },
+ {
+ "current": {
+ "value": "${VAR_CLUSTER_NAME}",
+ "text": "${VAR_CLUSTER_NAME}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "cluster_name",
+ "options": [
+ {
+ "value": "${VAR_CLUSTER_NAME}",
+ "text": "${VAR_CLUSTER_NAME}"
+ }
+ ],
+ "query": "${VAR_CLUSTER_NAME}",
+ "type": "constant"
+ },
+ {
+ "allValue": null,
+ "current": {},
+ "datasource": "${DS_LOCAL}",
+ "hide": 0,
+ "includeAll": false,
+ "label": "Workload Pool Name",
+ "multi": false,
+ "name": "pool_name",
+ "options": [],
+ "query": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {},
+ "datasource": "${DS_LOCAL}",
+ "hide": 0,
+ "includeAll": false,
+ "label": "RGW Host",
+ "multi": true,
+ "name": "rgw_name",
+ "options": [],
+ "query": "collectd.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "current": {
+ "value": "${VAR_DOMAIN}",
+ "text": "${VAR_DOMAIN}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "domain",
+ "options": [
+ {
+ "value": "${VAR_DOMAIN}",
+ "text": "${VAR_DOMAIN}"
+ }
+ ],
+ "query": "${VAR_DOMAIN}",
+ "type": "constant"
+ }
+ ]
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "Ceph Dashboard (Graphite)",
+ "version": 17
+}
\ No newline at end of file
--- /dev/null
+{
+ "__inputs": [
+ {
+ "name": "DS_LOCAL",
+ "label": "Local",
+ "description": "",
+ "type": "datasource",
+ "pluginId": "graphite",
+ "pluginName": "Graphite"
+ },
+ {
+ "name": "VAR_MONITOR",
+ "type": "constant",
+ "label": "monitor",
+ "value": "obj-mon-1.storage.lab",
+ "description": ""
+ },
+ {
+ "name": "VAR_CLUSTER_NAME",
+ "type": "constant",
+ "label": "cluster_name",
+ "value": "ceph",
+ "description": ""
+ },
+ {
+ "name": "VAR_DOMAIN",
+ "type": "constant",
+ "label": "domain",
+ "value": "storage.lab",
+ "description": ""
+ }
+ ],
+ "__requires": [
+ {
+ "type": "grafana",
+ "id": "grafana",
+ "name": "Grafana",
+ "version": "4.2.0"
+ },
+ {
+ "type": "panel",
+ "id": "graph",
+ "name": "Graph",
+ "version": ""
+ },
+ {
+ "type": "datasource",
+ "id": "graphite",
+ "name": "Graphite",
+ "version": "1.0.0"
+ },
+ {
+ "type": "panel",
+ "id": "singlestat",
+ "name": "Singlestat",
+ "version": ""
+ },
+ {
+ "type": "panel",
+ "id": "table",
+ "name": "Table",
+ "version": ""
+ }
+ ],
+ "annotations": {
+ "list": []
+ },
+ "editable": true,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": false,
+ "id": null,
+ "links": [],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": 243,
+ "panels": [
+ {
+ "cacheTimeout": null,
+ "colorBackground": true,
+ "colorValue": false,
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 28,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "refId": "A",
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.health"
+ }
+ ],
+ "thresholds": "1",
+ "title": "Health",
+ "type": "singlestat",
+ "valueFontSize": "100%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "OK",
+ "value": "0"
+ },
+ {
+ "op": "=",
+ "text": "Warning",
+ "value": "4"
+ },
+ {
+ "op": "=",
+ "text": "Error",
+ "value": "8"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 1,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_mon",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_mon\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_mon",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "Monitors",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 27,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "refId": "A",
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_osd"
+ }
+ ],
+ "thresholds": "",
+ "title": "OSDs",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 35,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "refId": "A",
+ "target": "sumSeries(offset(scale(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.vdb.osd_id,0),1))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "OSD Hosts",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 33,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "refId": "A",
+ "target": "sumSeries(offset(scale(collectd.*.$domain.cephmetrics.derive.$cluster_name.rgw.put,0),1))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "RGW Hosts",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 34,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "refId": "A",
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_mds_in"
+ }
+ ],
+ "thresholds": "",
+ "title": "MDS",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "bytes",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 7,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(193, 106, 31)",
+ "show": true
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.recovering_bytes_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.recovering_bytes_per_sec\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.recovering_bytes_per_sec",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "Recovery",
+ "type": "singlestat",
+ "valueFontSize": "70%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 9,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": true
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM \"measurement\" WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": false,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.read_op_per_sec"
+ },
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM \"measurement\" WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": false,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.write_op_per_sec"
+ },
+ {
+ "refId": "C",
+ "target": "sumSeries(#A, #B).select metric",
+ "targetFull": "sumSeries(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.read_op_per_sec, collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.write_op_per_sec).select metric"
+ }
+ ],
+ "thresholds": "",
+ "title": "Client IOPS",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "decimals": 1,
+ "format": "bytes",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 23,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": true
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_bytes_sec\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.read_bytes_sec"
+ },
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_bytes_sec\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.pools._all_.write_bytes_sec"
+ },
+ {
+ "refId": "C",
+ "target": "sumSeries(#A,#B).select metric",
+ "targetFull": "sumSeries(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.read_bytes_sec,collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.write_bytes_sec).select metric"
+ }
+ ],
+ "thresholds": "",
+ "title": "Client Load",
+ "type": "singlestat",
+ "valueFontSize": "70%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": true,
+ "colorValue": false,
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "decimals": 1,
+ "format": "short",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 37,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": "",
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 50, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "refId": "A",
+ "target": "percentileOfSeries(group(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.util),$percentile)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "70,90",
+ "title": "Disk Busy",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": true,
+ "colorValue": false,
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "decimals": 1,
+ "format": "short",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 36,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": "",
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 50, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "refId": "A",
+ "target": "percentileOfSeries(group(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.await),$percentile)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "20,60",
+ "title": "Latency(ms)",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "bytes",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 38,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "refId": "A",
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.osd_bytes_avail"
+ }
+ ],
+ "thresholds": "",
+ "title": "Free Space",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Overview",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 256,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 3,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 7,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "Raw Capacity",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.osd_bytes",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.osd_bytes, 'Raw')"
+ },
+ {
+ "alias": "Used",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.osd_bytes_used",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used, 'Used')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Cluster Capacity",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 17,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pool",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pool"
+ }
+ ],
+ "thresholds": "",
+ "title": "Pools",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 18,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": true
+ },
+ "span": 2,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "alias": "OSD's Up",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_in",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_up\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_osd, 'OSDs')"
+ },
+ {
+ "alias": "OSD's Up",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_in",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_up\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_osd_in, 'OSDs In')"
+ },
+ {
+ "alias": "OSD's Up",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_in",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_up\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_osd_up, 'OSDs Up')"
+ }
+ ],
+ "title": "OSD State",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Cluster Capacity",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 238,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 11,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec, 'Reads')"
+ },
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec, 'Writes')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Client Workload IOPS (pools: $pool_name)",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "IOPS",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 21,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_bytes_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec, 'Read')"
+ },
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_bytes_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec, 'Write')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Client Workload Throughput (pools: $pool_name)",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": "Bandwidth",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.recovering_bytes_per_sec": "#C15C17"
+ },
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 22,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.recovering_bytes_per_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.recovering_bytes_per_sec"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Recovery Overhead (pools: $pool_name)",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": "Bandwidth",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Workload Detail by Pool",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": false,
+ "height": 302,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 19,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 5,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 3,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_avgcount"
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_sum"
+ },
+ {
+ "refId": "C",
+ "target": "alias(divideSeries(#B, #A),\"GET\")",
+ "targetFull": "divideSeries(collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_sum, collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_avgcount).select metric",
+ "textEditor": true
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_avgcount"
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "E",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_sum"
+ },
+ {
+ "refId": "F",
+ "target": "alias(divideSeries(#E,#D), \"PUT\")",
+ "targetFull": "divideSeries(collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_sum,collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_avgcount).select metric",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Request Latency",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "s",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 25,
+ "legend": {
+ "alignAsTable": false,
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "rightSide": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 5,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 3,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.get",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.derive.ceph.rgw.get$/ WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get, 'GET')"
+ },
+ {
+ "alias": "PUT",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.get",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.derive.ceph.rgw.put$/ WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put, 'PUT')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Requests/sec",
+ "tooltip": {
+ "shared": true,
+ "sort": 1,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "",
+ "id": 26,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.qlen",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.qlen"
+ }
+ ],
+ "thresholds": "",
+ "title": "Queue",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 32,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 2,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 2,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(scale(averageSeries(collectd.$rgw_name.$domain.cpu.percent.idle),0.01), 1)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "CPU Busy",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "percent",
+ "label": "",
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 31,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 3,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 3,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(sumSeries(collectd.$rgw_name.$domain.interface.*.if_octets.rx), 'rx')"
+ },
+ {
+ "refId": "B",
+ "target": "alias(sumSeries(collectd.$rgw_name.$domain.interface.*.if_octets.tx), 'tx')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Network Load",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "Bps",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "RGW Host (S3/Swift)",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": "300",
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 24,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 4,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(sumSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.r_mbps), \"Read Throughput\")",
+ "textEditor": true
+ },
+ {
+ "refId": "B",
+ "target": "alias(sumSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.w_mbps), \"Write Throughput\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Backend Disk Load (MB/s) - all OSD's",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 40,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 4,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(percentileOfSeries(group(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.r_await),$percentile), \"Read Latency\")",
+ "textEditor": true
+ },
+ {
+ "refId": "C",
+ "target": "alias(percentileOfSeries(group(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.w_await),$percentile), \"Write Latency\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Backend Disk Latency (ms) - all OSD's - at $percentile%ile",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 43,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 4,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(percentileOfSeries(group(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.util),$percentile), \"disk busy %\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Overall Disk Busy at $percentile%ile",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 46,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 4,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(percentileOfSeries(group(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.iops),$percentile),\"IOPS/spindle\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "IOPS per Disk @ $percentile%ile - all OSDs",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 47,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 4,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(sumSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.iops),\"IOPS\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Backend IOPS - all OSD's",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 44,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 4,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(scale(collectd.*.$domain.cpu.percent.idle,0.01),1)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "CPU Busy",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "percent",
+ "label": "",
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Backend OSD Load Summary",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 39,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 1,
+ "desc": false
+ },
+ "span": 2,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.osd_id,1,-2)",
+ "textEditor": true
+ }
+ ],
+ "title": "Host/Disk to OSD ID Mapping",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 41,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": true
+ },
+ "span": 2,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 2,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.await,1,-3)",
+ "textEditor": true
+ }
+ ],
+ "title": "Disk Latency Breakdown (ms)",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 42,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": true
+ },
+ "span": 2,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 2,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.mbps,1,-3)",
+ "textEditor": true
+ }
+ ],
+ "title": "Disk Bandwidth (MB/s)",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 45,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": true
+ },
+ "span": 2,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 2,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.util,1,-3)",
+ "textEditor": true
+ }
+ ],
+ "title": "Disk %Util",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 48,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": true
+ },
+ "span": 2,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.iops,1,-3)",
+ "textEditor": true
+ }
+ ],
+ "title": "IOPS/Disk",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "OSD Detail",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "datasource": "${DS_LOCAL}",
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 10,
+ "links": [],
+ "minSpan": 3,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": null,
+ "desc": false
+ },
+ "span": 3,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "none"
+ }
+ ],
+ "targets": [
+ {
+ "alias": "Objects",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object, 'Objects')"
+ },
+ {
+ "alias": "Objects",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object_degraded, 'Objects degraded')"
+ },
+ {
+ "alias": "Objects",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy": "default",
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object_misplaced, 'Objects misplaced')"
+ },
+ {
+ "alias": "Objects",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy": "default",
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object_unfound, 'Objects unfound')"
+ }
+ ],
+ "title": "Object Summary",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "datasource": "${DS_LOCAL}",
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 13,
+ "links": [],
+ "minSpan": 3,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": null,
+ "desc": false
+ },
+ "span": 3,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "none"
+ }
+ ],
+ "targets": [
+ {
+ "alias": "PG's",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pg, 'PGs')"
+ },
+ {
+ "alias": "PG's",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pg_active, 'Active PGs')"
+ },
+ {
+ "alias": "PG's",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy": "default",
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pg_active_clean, 'Active+clean PGs')"
+ },
+ {
+ "alias": "PG's",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy": "default",
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pg_peering, 'PGs peering')"
+ }
+ ],
+ "title": "PG Summary",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "RADOS",
+ "titleSize": "h6"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [],
+ "templating": {
+ "list": [
+ {
+ "current": {
+ "value": "${VAR_MONITOR}",
+ "text": "${VAR_MONITOR}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "monitor",
+ "options": [
+ {
+ "value": "${VAR_MONITOR}",
+ "text": "${VAR_MONITOR}"
+ }
+ ],
+ "query": "${VAR_MONITOR}",
+ "type": "constant"
+ },
+ {
+ "current": {
+ "value": "${VAR_CLUSTER_NAME}",
+ "text": "${VAR_CLUSTER_NAME}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "cluster_name",
+ "options": [
+ {
+ "value": "${VAR_CLUSTER_NAME}",
+ "text": "${VAR_CLUSTER_NAME}"
+ }
+ ],
+ "query": "${VAR_CLUSTER_NAME}",
+ "type": "constant"
+ },
+ {
+ "allValue": null,
+ "current": {},
+ "datasource": "${DS_LOCAL}",
+ "hide": 0,
+ "includeAll": false,
+ "label": "Workload Pool Name",
+ "multi": false,
+ "name": "pool_name",
+ "options": [],
+ "query": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {},
+ "datasource": "${DS_LOCAL}",
+ "hide": 0,
+ "includeAll": false,
+ "label": "RGW Host",
+ "multi": true,
+ "name": "rgw_name",
+ "options": [],
+ "query": "collectd.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "current": {
+ "value": "${VAR_DOMAIN}",
+ "text": "${VAR_DOMAIN}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "domain",
+ "options": [
+ {
+ "value": "${VAR_DOMAIN}",
+ "text": "${VAR_DOMAIN}"
+ }
+ ],
+ "query": "${VAR_DOMAIN}",
+ "type": "constant"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "tags": [],
+ "text": "95",
+ "value": "95"
+ },
+ "hide": 0,
+ "includeAll": false,
+ "label": "Percentile",
+ "multi": false,
+ "name": "percentile",
+ "options": [
+ {
+ "selected": false,
+ "text": "80",
+ "value": "80"
+ },
+ {
+ "selected": false,
+ "text": "90",
+ "value": "90"
+ },
+ {
+ "selected": true,
+ "text": "95",
+ "value": "95"
+ },
+ {
+ "selected": false,
+ "text": "98",
+ "value": "98"
+ }
+ ],
+ "query": "80,90,95,98",
+ "type": "custom"
+ }
+ ]
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "Ceph Dashboard (Graphite)",
+ "version": 37
+}
\ No newline at end of file
--- /dev/null
+{
+ "__inputs": [
+ {
+ "name": "DS_LOCAL",
+ "label": "Local",
+ "description": "",
+ "type": "datasource",
+ "pluginId": "graphite",
+ "pluginName": "Graphite"
+ },
+ {
+ "name": "VAR_MONITOR",
+ "type": "constant",
+ "label": "monitor",
+ "value": "obj-mon-1.storage.lab",
+ "description": ""
+ },
+ {
+ "name": "VAR_CLUSTER_NAME",
+ "type": "constant",
+ "label": "cluster_name",
+ "value": "ceph",
+ "description": ""
+ },
+ {
+ "name": "VAR_DOMAIN",
+ "type": "constant",
+ "label": "domain",
+ "value": "storage.lab",
+ "description": ""
+ }
+ ],
+ "__requires": [
+ {
+ "type": "grafana",
+ "id": "grafana",
+ "name": "Grafana",
+ "version": "4.3.1"
+ },
+ {
+ "type": "panel",
+ "id": "graph",
+ "name": "Graph",
+ "version": ""
+ },
+ {
+ "type": "datasource",
+ "id": "graphite",
+ "name": "Graphite",
+ "version": "1.0.0"
+ },
+ {
+ "type": "panel",
+ "id": "singlestat",
+ "name": "Singlestat",
+ "version": ""
+ },
+ {
+ "type": "panel",
+ "id": "table",
+ "name": "Table",
+ "version": ""
+ }
+ ],
+ "annotations": {
+ "list": []
+ },
+ "editable": true,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": false,
+ "id": null,
+ "links": [],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": 243,
+ "panels": [
+ {
+ "cacheTimeout": null,
+ "colorBackground": true,
+ "colorValue": false,
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 28,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.health"
+ }
+ ],
+ "thresholds": "1",
+ "title": "Health",
+ "type": "singlestat",
+ "valueFontSize": "100%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "OK",
+ "value": "0"
+ },
+ {
+ "op": "=",
+ "text": "Warning",
+ "value": "4"
+ },
+ {
+ "op": "=",
+ "text": "Error",
+ "value": "8"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 1,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_mon",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_mon\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_mon",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "Monitors",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 27,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_osd"
+ }
+ ],
+ "thresholds": "",
+ "title": "OSDs",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 35,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "sumSeries(offset(scale(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.vdb.osd_id,0),1))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "OSD Hosts",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 33,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "sumSeries(offset(scale(collectd.*.$domain.cephmetrics.derive.$cluster_name.rgw.put,0),1))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "RGW Hosts",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 34,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_mds_in"
+ }
+ ],
+ "thresholds": "",
+ "title": "MDS",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "bytes",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 7,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(193, 106, 31)",
+ "show": true
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.recovering_bytes_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.recovering_bytes_per_sec\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.recovering_bytes_per_sec",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "Recovery",
+ "type": "singlestat",
+ "valueFontSize": "70%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 9,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": true
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM \"measurement\" WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": false,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.read_op_per_sec"
+ },
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM \"measurement\" WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": false,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.write_op_per_sec"
+ },
+ {
+ "refId": "C",
+ "target": "sumSeries(#A, #B).select metric",
+ "targetFull": "sumSeries(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.read_op_per_sec, collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.write_op_per_sec).select metric"
+ }
+ ],
+ "thresholds": "",
+ "title": "Client IOPS",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "decimals": 1,
+ "format": "bytes",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 23,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": true
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_bytes_sec\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.read_bytes_sec"
+ },
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_bytes_sec\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.pools._all_.write_bytes_sec"
+ },
+ {
+ "refId": "C",
+ "target": "sumSeries(#A,#B).select metric",
+ "targetFull": "sumSeries(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.read_bytes_sec,collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools._all_.write_bytes_sec).select metric"
+ }
+ ],
+ "thresholds": "",
+ "title": "Client Load",
+ "type": "singlestat",
+ "valueFontSize": "70%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": true,
+ "colorValue": false,
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "decimals": 1,
+ "format": "short",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 37,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": "",
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 50, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "percentileOfSeries(group(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.util),$percentile)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "70,90",
+ "title": "Disk Busy",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": true,
+ "colorValue": false,
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "decimals": 1,
+ "format": "short",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 36,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": "",
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 50, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "percentileOfSeries(group(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.await),$percentile)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "20,60",
+ "title": "Latency(ms)",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "bytes",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 38,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.osd_bytes_avail"
+ }
+ ],
+ "thresholds": "",
+ "title": "Free Space",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Overview",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 256,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 3,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 7,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "Raw Capacity",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.osd_bytes",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.osd_bytes, 'Raw')"
+ },
+ {
+ "alias": "Used",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.osd_bytes_used",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used, 'Used')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Cluster Capacity",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 17,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pool",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pool"
+ }
+ ],
+ "thresholds": "",
+ "title": "Pools",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 18,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": true
+ },
+ "span": 2,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "alias": "OSD's Up",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_in",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_up\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_osd, 'OSDs')"
+ },
+ {
+ "alias": "OSD's Up",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_in",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_up\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_osd_in, 'OSDs In')"
+ },
+ {
+ "alias": "OSD's Up",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_in",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_osd_up\" WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_osd_up, 'OSDs Up')"
+ }
+ ],
+ "title": "OSD State",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Cluster Capacity",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 238,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 11,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec, 'Reads')"
+ },
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec, 'Writes')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Client Workload IOPS (pools: $pool_name)",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "IOPS",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 21,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_bytes_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec, 'Read')"
+ },
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_bytes_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec, 'Write')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Client Workload Throughput (pools: $pool_name)",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": "Bandwidth",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.recovering_bytes_per_sec": "#C15C17"
+ },
+ "bars": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 22,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "",
+ "dsType": "influxdb",
+ "groupBy": [],
+ "measurement": "/collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools.$pool_name.read_op_per_sec/",
+ "policy": "default",
+ "query": "SELECT \"value\" FROM /collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.recovering_bytes_per_sec/ WHERE $timeFilter",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.recovering_bytes_per_sec"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Recovery Overhead (pools: $pool_name)",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": "Bandwidth",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Workload Detail by Pool",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 302,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 19,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 5,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 3,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_avgcount"
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_sum"
+ },
+ {
+ "refId": "C",
+ "target": "alias(divideSeries(#B, #A),\"GET\")",
+ "targetFull": "divideSeries(collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_sum, collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_avgcount).select metric",
+ "textEditor": true
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_avgcount"
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "E",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_sum"
+ },
+ {
+ "refId": "F",
+ "target": "alias(divideSeries(#E,#D), \"PUT\")",
+ "targetFull": "divideSeries(collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_sum,collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_avgcount).select metric",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Request Latency",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "s",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 25,
+ "legend": {
+ "alignAsTable": false,
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "rightSide": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 5,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 3,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.get",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.derive.ceph.rgw.get$/ WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.get, 'GET')"
+ },
+ {
+ "alias": "PUT",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.get",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.derive.ceph.rgw.put$/ WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.put, 'PUT')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Requests/sec",
+ "tooltip": {
+ "shared": true,
+ "sort": 1,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "${DS_LOCAL}",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "",
+ "id": 26,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.qlen",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_name.$domain.cephmetrics.derive.$cluster_name.rgw.qlen"
+ }
+ ],
+ "thresholds": "",
+ "title": "Queue",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 32,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 2,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 2,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(scale(averageSeries(collectd.$rgw_name.$domain.cpu.percent.idle),0.01), 1)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "CPU Busy",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "percent",
+ "label": "",
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 31,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 3,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 3,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(sumSeries(collectd.$rgw_name.$domain.interface.*.if_octets.rx), 'rx')"
+ },
+ {
+ "refId": "B",
+ "target": "alias(sumSeries(collectd.$rgw_name.$domain.interface.*.if_octets.tx), 'tx')"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Network Load",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "Bps",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "RGW Host (S3/Swift)",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": false,
+ "height": "300",
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 24,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 4,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(sumSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.r_mbps), \"Read Throughput\")",
+ "textEditor": true
+ },
+ {
+ "refId": "B",
+ "target": "alias(sumSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.w_mbps), \"Write Throughput\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Backend Disk Load (MB/s) - all OSD's",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 40,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [
+ {
+ "dashUri": "db/latency-by-server",
+ "dashboard": "Latency by Server",
+ "includeVars": true,
+ "keepTime": true,
+ "targetBlank": true,
+ "title": "Latency by Server",
+ "type": "dashboard"
+ }
+ ],
+ "minSpan": 4,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(percentileOfSeries(group(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.r_await),$percentile), \"Read Latency\")",
+ "textEditor": true
+ },
+ {
+ "refId": "C",
+ "target": "alias(percentileOfSeries(group(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.w_await),$percentile), \"Write Latency\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Backend Disk Latency (ms) - all OSD's - at $percentile%ile",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 43,
+ "legend": {
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [
+ {
+ "dashUri": "db/disk-busy-by-server",
+ "dashboard": "Disk Busy by Server",
+ "includeVars": true,
+ "keepTime": true,
+ "targetBlank": true,
+ "title": "Disk Busy by Server",
+ "type": "dashboard"
+ }
+ ],
+ "minSpan": 4,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(percentileOfSeries(group(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.util),$percentile), \"disk busy %\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Overall Disk Busy at $percentile%ile",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 46,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 4,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(percentileOfSeries(group(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.iops),$percentile),\"IOPS/spindle\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "IOPS per Disk @ $percentile%ile - all OSDs",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 47,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [
+ {
+ "dashUri": "db/iops-by-server",
+ "dashboard": "IOPS by Server",
+ "includeVars": true,
+ "keepTime": true,
+ "targetBlank": true,
+ "title": "IOPS by Server",
+ "type": "dashboard"
+ }
+ ],
+ "minSpan": 4,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(sumSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.iops),\"IOPS\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Backend IOPS - all OSD's",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 44,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 4,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(scale(collectd.*.$domain.cpu.percent.idle,0.01),1)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "CPU Busy",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "percent",
+ "label": "",
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Backend OSD Load Summary",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 39,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 1,
+ "desc": false
+ },
+ "span": 2,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.osd_id,1,-2)",
+ "textEditor": true
+ }
+ ],
+ "title": "Host/Disk to OSD ID Mapping",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 41,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": true
+ },
+ "span": 2,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 2,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.await,1,-3)",
+ "textEditor": true
+ }
+ ],
+ "title": "Disk Latency Breakdown (ms)",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 42,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": true
+ },
+ "span": 2,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 2,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.mbps,1,-3)",
+ "textEditor": true
+ }
+ ],
+ "title": "Disk Bandwidth (MB/s)",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 45,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": true
+ },
+ "span": 2,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 2,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.util,1,-3)",
+ "textEditor": true
+ }
+ ],
+ "title": "Disk %Util",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 48,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": true
+ },
+ "span": 2,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.iops,1,-3)",
+ "textEditor": true
+ }
+ ],
+ "title": "IOPS/Disk",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "OSD Detail",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "datasource": "${DS_LOCAL}",
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 10,
+ "links": [],
+ "minSpan": 3,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": null,
+ "desc": false
+ },
+ "span": 3,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "none"
+ }
+ ],
+ "targets": [
+ {
+ "alias": "Objects",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object, 'Objects')"
+ },
+ {
+ "alias": "Objects",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object_degraded, 'Objects degraded')"
+ },
+ {
+ "alias": "Objects",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy": "default",
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object_misplaced, 'Objects misplaced')"
+ },
+ {
+ "alias": "Objects",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy": "default",
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_object_unfound, 'Objects unfound')"
+ }
+ ],
+ "title": "Object Summary",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "datasource": "${DS_LOCAL}",
+ "filterNull": false,
+ "fontSize": "100%",
+ "id": 13,
+ "links": [],
+ "minSpan": 3,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": null,
+ "desc": false
+ },
+ "span": 3,
+ "styles": [
+ {
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 0,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "none"
+ }
+ ],
+ "targets": [
+ {
+ "alias": "PG's",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy": "default",
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pg, 'PGs')"
+ },
+ {
+ "alias": "PG's",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy": "default",
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pg_active, 'Active PGs')"
+ },
+ {
+ "alias": "PG's",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy": "default",
+ "refId": "C",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pg_active_clean, 'Active+clean PGs')"
+ },
+ {
+ "alias": "PG's",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy": "default",
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.num_pg_peering, 'PGs peering')"
+ }
+ ],
+ "title": "PG Summary",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "RADOS",
+ "titleSize": "h6"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [],
+ "templating": {
+ "list": [
+ {
+ "current": {
+ "value": "${VAR_MONITOR}",
+ "text": "${VAR_MONITOR}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "monitor",
+ "options": [
+ {
+ "value": "${VAR_MONITOR}",
+ "text": "${VAR_MONITOR}"
+ }
+ ],
+ "query": "${VAR_MONITOR}",
+ "type": "constant"
+ },
+ {
+ "current": {
+ "value": "${VAR_CLUSTER_NAME}",
+ "text": "${VAR_CLUSTER_NAME}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "cluster_name",
+ "options": [
+ {
+ "value": "${VAR_CLUSTER_NAME}",
+ "text": "${VAR_CLUSTER_NAME}"
+ }
+ ],
+ "query": "${VAR_CLUSTER_NAME}",
+ "type": "constant"
+ },
+ {
+ "allValue": null,
+ "current": {},
+ "datasource": "${DS_LOCAL}",
+ "hide": 0,
+ "includeAll": false,
+ "label": "Workload Pool Name",
+ "multi": false,
+ "name": "pool_name",
+ "options": [],
+ "query": "collectd.$monitor.cephmetrics.gauge.$cluster_name.mon.pools.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {},
+ "datasource": "${DS_LOCAL}",
+ "hide": 0,
+ "includeAll": false,
+ "label": "RGW Host",
+ "multi": false,
+ "name": "rgw_name",
+ "options": [],
+ "query": "collectd.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "current": {
+ "value": "${VAR_DOMAIN}",
+ "text": "${VAR_DOMAIN}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "domain",
+ "options": [
+ {
+ "value": "${VAR_DOMAIN}",
+ "text": "${VAR_DOMAIN}"
+ }
+ ],
+ "query": "${VAR_DOMAIN}",
+ "type": "constant"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "tags": [],
+ "text": "95",
+ "value": "95"
+ },
+ "hide": 0,
+ "includeAll": false,
+ "label": "Percentile",
+ "multi": false,
+ "name": "percentile",
+ "options": [
+ {
+ "selected": false,
+ "text": "80",
+ "value": "80"
+ },
+ {
+ "selected": false,
+ "text": "90",
+ "value": "90"
+ },
+ {
+ "selected": true,
+ "text": "95",
+ "value": "95"
+ },
+ {
+ "selected": false,
+ "text": "98",
+ "value": "98"
+ }
+ ],
+ "query": "80,90,95,98",
+ "type": "custom"
+ }
+ ]
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "Ceph Dashboard (Graphite)",
+ "version": 43
+}
\ No newline at end of file
--- /dev/null
+{
+ "__inputs": [
+ {
+ "name": "DS_LOCAL",
+ "label": "Local",
+ "description": "",
+ "type": "datasource",
+ "pluginId": "graphite",
+ "pluginName": "Graphite"
+ },
+ {
+ "name": "VAR_DOMAIN",
+ "type": "constant",
+ "label": "domain",
+ "value": "storage.lab",
+ "description": ""
+ },
+ {
+ "name": "VAR_CEPH_CLUSTER",
+ "type": "constant",
+ "label": "ceph_cluster",
+ "value": "ceph",
+ "description": ""
+ }
+ ],
+ "__requires": [
+ {
+ "type": "grafana",
+ "id": "grafana",
+ "name": "Grafana",
+ "version": "4.3.1"
+ },
+ {
+ "type": "panel",
+ "id": "graph",
+ "name": "Graph",
+ "version": ""
+ },
+ {
+ "type": "datasource",
+ "id": "graphite",
+ "name": "Graphite",
+ "version": "1.0.0"
+ }
+ ],
+ "annotations": {
+ "list": []
+ },
+ "editable": true,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": false,
+ "id": null,
+ "links": [],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 8,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 12,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": null,
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 12,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.$osd_servers.$domain.cephmetrics.gauge.$ceph_cluster.osd.*.perf.util,1,\"maxSeries\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers OSD Servers Disk Utilization Peak",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "All Servers by Highest Disk %Util",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 5,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [
+ {
+ "dashUri": "db/osd-node-detail",
+ "dashboard": "OSD Node Detail",
+ "includeVars": true,
+ "keepTime": true,
+ "targetBlank": true,
+ "title": "OSD Node Details",
+ "type": "dashboard"
+ }
+ ],
+ "minSpan": 3,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": "osd_servers",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(percentileOfSeries(group(collectd.$osd_servers.$domain.cephmetrics.gauge.$ceph_cluster.osd.*.perf.util),$percentile),\"all disk busy @$percentile%ile\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers Disk Utilisation @ $percentile%ile",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Each OSD Node's $percentile%ile Utilisation",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": false,
+ "title": "Dashboard Row",
+ "titleSize": "h6"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [],
+ "templating": {
+ "list": [
+ {
+ "current": {
+ "value": "${VAR_DOMAIN}",
+ "text": "${VAR_DOMAIN}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "domain",
+ "options": [
+ {
+ "value": "${VAR_DOMAIN}",
+ "text": "${VAR_DOMAIN}"
+ }
+ ],
+ "query": "${VAR_DOMAIN}",
+ "type": "constant"
+ },
+ {
+ "current": {
+ "value": "${VAR_CEPH_CLUSTER}",
+ "text": "${VAR_CEPH_CLUSTER}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "ceph_cluster",
+ "options": [
+ {
+ "value": "${VAR_CEPH_CLUSTER}",
+ "text": "${VAR_CEPH_CLUSTER}"
+ }
+ ],
+ "query": "${VAR_CEPH_CLUSTER}",
+ "type": "constant"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "95",
+ "value": "95"
+ },
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "percentile",
+ "options": [
+ {
+ "selected": false,
+ "text": "80",
+ "value": "80"
+ },
+ {
+ "selected": false,
+ "text": "85",
+ "value": "85"
+ },
+ {
+ "selected": false,
+ "text": "90",
+ "value": "90"
+ },
+ {
+ "selected": true,
+ "text": "95",
+ "value": "95"
+ },
+ {
+ "selected": false,
+ "text": "98",
+ "value": "98"
+ }
+ ],
+ "query": "80,85,90,95,98",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "text": "All",
+ "value": "$__all"
+ },
+ "hide": 2,
+ "includeAll": true,
+ "label": null,
+ "multi": true,
+ "name": "osd_servers",
+ "options": [
+ {
+ "selected": true,
+ "text": "All",
+ "value": "$__all"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-1",
+ "value": "obj-osd-1"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-2",
+ "value": "obj-osd-2"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-3",
+ "value": "obj-osd-3"
+ }
+ ],
+ "query": "obj-osd-1,obj-osd-2,obj-osd-3",
+ "type": "custom"
+ }
+ ]
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "Disk Busy by Server",
+ "version": 25
+}
\ No newline at end of file
--- /dev/null
+{
+ "__inputs": [
+ {
+ "name": "DS_LOCAL",
+ "label": "Local",
+ "description": "",
+ "type": "datasource",
+ "pluginId": "graphite",
+ "pluginName": "Graphite"
+ },
+ {
+ "name": "VAR_DOMAIN",
+ "type": "constant",
+ "label": "domain",
+ "value": "storage.lab",
+ "description": ""
+ },
+ {
+ "name": "VAR_CEPH_CLUSTER",
+ "type": "constant",
+ "label": "ceph_cluster",
+ "value": "ceph",
+ "description": ""
+ }
+ ],
+ "__requires": [
+ {
+ "type": "grafana",
+ "id": "grafana",
+ "name": "Grafana",
+ "version": "4.3.1"
+ },
+ {
+ "type": "panel",
+ "id": "graph",
+ "name": "Graph",
+ "version": ""
+ },
+ {
+ "type": "datasource",
+ "id": "graphite",
+ "name": "Graphite",
+ "version": "1.0.0"
+ }
+ ],
+ "annotations": {
+ "list": []
+ },
+ "editable": true,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": false,
+ "id": null,
+ "links": [],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 8,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 12,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": null,
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 12,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.$osd_servers.$domain.cephmetrics.gauge.$ceph_cluster.osd.*.perf.iops,1,\"sumSeries\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers OSD Server IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "All Servers by IOPS",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 5,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [
+ {
+ "dashUri": "db/osd-node-detail",
+ "dashboard": "OSD Node Detail",
+ "includeVars": true,
+ "keepTime": true,
+ "targetBlank": true,
+ "title": "OSD Node Details",
+ "type": "dashboard"
+ }
+ ],
+ "minSpan": 3,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": "osd_servers",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "group(collectd.$osd_servers.$domain.cephmetrics.gauge.$ceph_cluster.osd.*.perf.iops)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers Total OSD IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Each OSD Node's IOPS Load",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": false,
+ "title": "Dashboard Row",
+ "titleSize": "h6"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [],
+ "templating": {
+ "list": [
+ {
+ "current": {
+ "value": "${VAR_DOMAIN}",
+ "text": "${VAR_DOMAIN}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "domain",
+ "options": [
+ {
+ "value": "${VAR_DOMAIN}",
+ "text": "${VAR_DOMAIN}"
+ }
+ ],
+ "query": "${VAR_DOMAIN}",
+ "type": "constant"
+ },
+ {
+ "current": {
+ "value": "${VAR_CEPH_CLUSTER}",
+ "text": "${VAR_CEPH_CLUSTER}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "ceph_cluster",
+ "options": [
+ {
+ "value": "${VAR_CEPH_CLUSTER}",
+ "text": "${VAR_CEPH_CLUSTER}"
+ }
+ ],
+ "query": "${VAR_CEPH_CLUSTER}",
+ "type": "constant"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "text": "All",
+ "value": "$__all"
+ },
+ "hide": 2,
+ "includeAll": true,
+ "label": null,
+ "multi": true,
+ "name": "osd_servers",
+ "options": [
+ {
+ "selected": true,
+ "text": "All",
+ "value": "$__all"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-1",
+ "value": "obj-osd-1"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-2",
+ "value": "obj-osd-2"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-3",
+ "value": "obj-osd-3"
+ }
+ ],
+ "query": "obj-osd-1,obj-osd-2,obj-osd-3",
+ "type": "custom"
+ }
+ ]
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "IOPS by Server",
+ "version": 2
+}
\ No newline at end of file
--- /dev/null
+{
+ "__inputs": [
+ {
+ "name": "DS_LOCAL",
+ "label": "Local",
+ "description": "",
+ "type": "datasource",
+ "pluginId": "graphite",
+ "pluginName": "Graphite"
+ },
+ {
+ "name": "VAR_DOMAIN",
+ "type": "constant",
+ "label": "domain",
+ "value": "storage.lab",
+ "description": ""
+ },
+ {
+ "name": "VAR_CEPH_CLUSTER",
+ "type": "constant",
+ "label": "ceph_cluster",
+ "value": "ceph",
+ "description": ""
+ }
+ ],
+ "__requires": [
+ {
+ "type": "grafana",
+ "id": "grafana",
+ "name": "Grafana",
+ "version": "4.3.1"
+ },
+ {
+ "type": "panel",
+ "id": "graph",
+ "name": "Graph",
+ "version": ""
+ },
+ {
+ "type": "datasource",
+ "id": "graphite",
+ "name": "Graphite",
+ "version": "1.0.0"
+ }
+ ],
+ "annotations": {
+ "list": []
+ },
+ "editable": true,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": false,
+ "id": null,
+ "links": [],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 8,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 12,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": null,
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 12,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.$osd_servers.$domain.cephmetrics.gauge.$ceph_cluster.osd.*.perf.await,1,\"maxSeries\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers OSD Servers - Highest Latency",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "All Servers by IOPS",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "${DS_LOCAL}",
+ "fill": 1,
+ "id": 5,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [
+ {
+ "dashUri": "db/osd-node-detail",
+ "dashboard": "OSD Node Detail",
+ "includeVars": true,
+ "keepTime": true,
+ "targetBlank": true,
+ "title": "OSD Node Details",
+ "type": "dashboard"
+ }
+ ],
+ "minSpan": 3,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": "osd_servers",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "group(collectd.$osd_servers.$domain.cephmetrics.gauge.$ceph_cluster.osd.*.perf.await)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers Latency",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Each OSD Node's IOPS Load",
+ "titleSize": "h6"
+ },
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": false,
+ "title": "Dashboard Row",
+ "titleSize": "h6"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [],
+ "templating": {
+ "list": [
+ {
+ "current": {
+ "value": "${VAR_DOMAIN}",
+ "text": "${VAR_DOMAIN}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "domain",
+ "options": [
+ {
+ "value": "${VAR_DOMAIN}",
+ "text": "${VAR_DOMAIN}"
+ }
+ ],
+ "query": "${VAR_DOMAIN}",
+ "type": "constant"
+ },
+ {
+ "current": {
+ "value": "${VAR_CEPH_CLUSTER}",
+ "text": "${VAR_CEPH_CLUSTER}"
+ },
+ "hide": 2,
+ "label": null,
+ "name": "ceph_cluster",
+ "options": [
+ {
+ "value": "${VAR_CEPH_CLUSTER}",
+ "text": "${VAR_CEPH_CLUSTER}"
+ }
+ ],
+ "query": "${VAR_CEPH_CLUSTER}",
+ "type": "constant"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "text": "All",
+ "value": "$__all"
+ },
+ "hide": 2,
+ "includeAll": true,
+ "label": null,
+ "multi": true,
+ "name": "osd_servers",
+ "options": [
+ {
+ "selected": true,
+ "text": "All",
+ "value": "$__all"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-1",
+ "value": "obj-osd-1"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-2",
+ "value": "obj-osd-2"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-3",
+ "value": "obj-osd-3"
+ }
+ ],
+ "query": "obj-osd-1,obj-osd-2,obj-osd-3",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "95",
+ "value": "95"
+ },
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "percentile",
+ "options": [
+ {
+ "selected": true,
+ "text": "95",
+ "value": "95"
+ }
+ ],
+ "query": "95",
+ "type": "custom"
+ }
+ ]
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "Latency by Server",
+ "version": 1
+}
\ No newline at end of file
--- /dev/null
+{
+ "meta" : {
+ "expires" : "0001-01-01T00:00:00Z",
+ "canSave" : true,
+ "created" : "2017-08-03T21:42:28Z",
+ "canStar" : true,
+ "slug" : "alert-status",
+ "createdBy" : "admin",
+ "canEdit" : true,
+ "updated" : "2017-08-18T05:26:10Z",
+ "version" : 15,
+ "updatedBy" : "admin",
+ "type" : "db"
+ },
+ "dashboard" : {
+ "version" : 15,
+ "timepicker" : {
+ "time_options" : [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ],
+ "refresh_intervals" : [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ]
+ },
+ "refresh" : "10s",
+ "hideControls" : true,
+ "id" : 24,
+ "annotations" : {
+ "list" : []
+ },
+ "style" : "dark",
+ "gnetId" : null,
+ "timezone" : "browser",
+ "schemaVersion" : 14,
+ "time" : {
+ "from" : "now-1h",
+ "to" : "now"
+ },
+ "rows" : [
+ {
+ "panels" : [
+ {
+ "limit" : "20",
+ "title" : "Active Ceph Alert List",
+ "span" : 12,
+ "id" : 1,
+ "sortOrder" : 3,
+ "onlyAlertsOnDashboard" : true,
+ "links" : [],
+ "show" : "current",
+ "type" : "alertlist",
+ "stateFilter" : [
+ "alerting"
+ ]
+ }
+ ],
+ "repeatIteration" : null,
+ "repeat" : null,
+ "showTitle" : false,
+ "collapse" : false,
+ "title" : "Dashboard Row",
+ "repeatRowId" : null,
+ "height" : "250px",
+ "titleSize" : "h6"
+ },
+ {
+ "height" : 250,
+ "titleSize" : "h5",
+ "title" : "Health Checks",
+ "collapse" : false,
+ "repeatRowId" : null,
+ "showTitle" : true,
+ "panels" : [
+ {
+ "legend" : {
+ "min" : false,
+ "values" : false,
+ "current" : false,
+ "show" : true,
+ "total" : false,
+ "avg" : false,
+ "max" : false
+ },
+ "dashes" : false,
+ "hideTimeOverride" : false,
+ "percentage" : false,
+ "maxDataPoints" : "360",
+ "alert" : {
+ "notifications" : [
+ {
+ "id" : 1
+ }
+ ],
+ "name" : "Overall Ceph Health",
+ "conditions" : [
+ {
+ "query" : {
+ "params" : [
+ "A",
+ "20s",
+ "now"
+ ]
+ },
+ "reducer" : {
+ "params" : [],
+ "type" : "last"
+ },
+ "operator" : {
+ "type" : "and"
+ },
+ "evaluator" : {
+ "type" : "gt",
+ "params" : [
+ 0
+ ]
+ },
+ "type" : "query"
+ }
+ ],
+ "message" : "Cluster Health is not OK",
+ "handler" : 1,
+ "frequency" : "10s",
+ "executionErrorState" : "keep_state",
+ "noDataState" : "no_data"
+ },
+ "id" : 2,
+ "points" : false,
+ "spaceLength" : 10,
+ "renderer" : "flot",
+ "minSpan" : 2,
+ "dashLength" : 10,
+ "pointradius" : 5,
+ "xaxis" : {
+ "values" : [],
+ "name" : null,
+ "show" : true,
+ "buckets" : null,
+ "mode" : "time"
+ },
+ "yaxes" : [
+ {
+ "format" : "short",
+ "max" : "10",
+ "label" : "",
+ "show" : true,
+ "min" : "0",
+ "logBase" : 1
+ },
+ {
+ "max" : null,
+ "format" : "short",
+ "show" : false,
+ "label" : null,
+ "logBase" : 1,
+ "min" : null
+ }
+ ],
+ "bars" : false,
+ "description" : "The chart plots the clusters health, over time. Health is depicted as a integer; 0, 4 or 8 where 0 is OK, 4 is WARN and 8 represents an ERROR state.",
+ "thresholds" : [
+ {
+ "fill" : true,
+ "colorMode" : "critical",
+ "op" : "gt",
+ "line" : true,
+ "value" : 0
+ }
+ ],
+ "tooltip" : {
+ "shared" : false,
+ "value_type" : "individual",
+ "sort" : 1
+ },
+ "targets" : [
+ {
+ "target" : "alias(maxSeries(consolidateBy(keepLastValue(transformNull(collectd.*.$domain.cephmetrics.gauge.*.mon.health,0)),\"max\")),\"Ceph Health\")",
+ "textEditor" : true,
+ "refId" : "A"
+ }
+ ],
+ "linewidth" : 2,
+ "stack" : false,
+ "title" : "Overall Ceph Health",
+ "nullPointMode" : "null",
+ "span" : 2,
+ "seriesOverrides" : [],
+ "lines" : true,
+ "datasource" : "Local",
+ "fill" : 1,
+ "timeShift" : null,
+ "links" : [],
+ "type" : "graph",
+ "timeFrom" : null,
+ "steppedLine" : true,
+ "aliasColors" : {
+ "Ceph Health" : "#890F02",
+ "Ceph Health (0:OK, 4:Warning,8:Error)" : "#DEDAF7",
+ "ceph health" : "#890F02"
+ }
+ },
+ {
+ "percentage" : false,
+ "dashes" : false,
+ "legend" : {
+ "current" : false,
+ "show" : false,
+ "min" : false,
+ "values" : false,
+ "max" : false,
+ "total" : false,
+ "avg" : false
+ },
+ "spaceLength" : 10,
+ "id" : 3,
+ "points" : false,
+ "alert" : {
+ "name" : "Disks Near Full",
+ "notifications" : [
+ {
+ "id" : 1
+ }
+ ],
+ "message" : "DIsks Near full detected within the cluster. Warning threshold is 80% full.",
+ "conditions" : [
+ {
+ "operator" : {
+ "type" : "and"
+ },
+ "reducer" : {
+ "type" : "max",
+ "params" : []
+ },
+ "query" : {
+ "params" : [
+ "A",
+ "1m",
+ "now"
+ ]
+ },
+ "type" : "query",
+ "evaluator" : {
+ "params" : [
+ 0
+ ],
+ "type" : "gt"
+ }
+ }
+ ],
+ "frequency" : "60s",
+ "executionErrorState" : "keep_state",
+ "handler" : 1,
+ "noDataState" : "ok"
+ },
+ "pointradius" : 5,
+ "renderer" : "flot",
+ "minSpan" : 2,
+ "dashLength" : 10,
+ "yaxes" : [
+ {
+ "min" : "0",
+ "logBase" : 1,
+ "label" : null,
+ "show" : true,
+ "format" : "short",
+ "max" : null
+ },
+ {
+ "label" : null,
+ "show" : false,
+ "min" : null,
+ "logBase" : 1,
+ "format" : "short",
+ "max" : null
+ }
+ ],
+ "xaxis" : {
+ "mode" : "time",
+ "values" : [],
+ "name" : null,
+ "show" : true,
+ "buckets" : null
+ },
+ "description" : "This shows how many disks are at or above 80% full. Performance may degrade beyond this threshold on filestore (XFS) backed OSD's.",
+ "bars" : false,
+ "tooltip" : {
+ "value_type" : "individual",
+ "sort" : 0,
+ "shared" : true
+ },
+ "targets" : [
+ {
+ "textEditor" : true,
+ "target" : "currentAbove(transformNull(keepLastValue(collectd.*.$domain.cephmetrics.gauge.*.osd.*.osd_percent_used),0),85)",
+ "refId" : "A",
+ "hide" : true
+ },
+ {
+ "target" : "alias(countSeries(#A),\"OSDs Near Full\")",
+ "textEditor" : true,
+ "refId" : "B",
+ "targetFull" : "alias(countSeries(currentAbove(transformNull(keepLastValue(collectd.*.$domain.cephmetrics.gauge.*.osd.*.osd_percent_used),0),85)),\"OSDs Near Full\")"
+ }
+ ],
+ "linewidth" : 1,
+ "thresholds" : [
+ {
+ "colorMode" : "critical",
+ "fill" : true,
+ "value" : 0,
+ "op" : "gt",
+ "line" : true
+ }
+ ],
+ "datasource" : "Local",
+ "lines" : true,
+ "title" : "Disks Near Full",
+ "stack" : false,
+ "nullPointMode" : "null",
+ "span" : 2,
+ "seriesOverrides" : [],
+ "aliasColors" : {},
+ "steppedLine" : false,
+ "timeShift" : null,
+ "links" : [],
+ "fill" : 1,
+ "type" : "graph",
+ "timeFrom" : null
+ },
+ {
+ "hideTimeOverride" : true,
+ "percentage" : false,
+ "dashes" : false,
+ "legend" : {
+ "current" : false,
+ "min" : false,
+ "alignAsTable" : false,
+ "max" : false,
+ "total" : false,
+ "show" : false,
+ "rightSide" : false,
+ "values" : false,
+ "avg" : false,
+ "hideZero" : false
+ },
+ "spaceLength" : 10,
+ "points" : false,
+ "id" : 4,
+ "alert" : {
+ "name" : "OSDs Down",
+ "notifications" : [
+ {
+ "id" : 1
+ }
+ ],
+ "conditions" : [
+ {
+ "evaluator" : {
+ "type" : "gt",
+ "params" : [
+ 0
+ ]
+ },
+ "type" : "query",
+ "query" : {
+ "params" : [
+ "C",
+ "30s",
+ "now"
+ ]
+ },
+ "reducer" : {
+ "params" : [],
+ "type" : "max"
+ },
+ "operator" : {
+ "type" : "and"
+ }
+ }
+ ],
+ "message" : "OSD Down event",
+ "handler" : 1,
+ "executionErrorState" : "alerting",
+ "frequency" : "10s",
+ "noDataState" : "ok"
+ },
+ "pointradius" : 5,
+ "dashLength" : 10,
+ "minSpan" : 2,
+ "renderer" : "flot",
+ "yaxes" : [
+ {
+ "format" : "short",
+ "max" : null,
+ "label" : null,
+ "show" : true,
+ "min" : "0",
+ "logBase" : 1
+ },
+ {
+ "logBase" : 1,
+ "min" : null,
+ "show" : false,
+ "label" : null,
+ "max" : null,
+ "format" : "short"
+ }
+ ],
+ "xaxis" : {
+ "mode" : "time",
+ "show" : true,
+ "buckets" : null,
+ "name" : null,
+ "values" : []
+ },
+ "description" : "Count of OSDs currently in a DOWN state",
+ "bars" : true,
+ "linewidth" : 2,
+ "tooltip" : {
+ "shared" : true,
+ "value_type" : "individual",
+ "sort" : 0
+ },
+ "targets" : [
+ {
+ "target" : "alias(keepLastValue(consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.*.mon.num_osd), \"max\")),\"total\")",
+ "textEditor" : true,
+ "hide" : true,
+ "refId" : "A"
+ },
+ {
+ "hide" : true,
+ "refId" : "B",
+ "target" : "alias(keepLastValue(consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.*.mon.num_osd_up), \"max\")),\"up\")",
+ "textEditor" : true
+ },
+ {
+ "targetFull" : "alias(diffSeries(alias(keepLastValue(consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.*.mon.num_osd), \"max\")),\"total\"),alias(keepLastValue(consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.*.mon.num_osd_up), \"max\")),\"up\")), \"down\")",
+ "refId" : "C",
+ "hide" : false,
+ "textEditor" : true,
+ "target" : "alias(diffSeries(#A,#B), \"down\")"
+ }
+ ],
+ "thresholds" : [
+ {
+ "op" : "gt",
+ "line" : true,
+ "value" : 0,
+ "fill" : true,
+ "colorMode" : "critical"
+ }
+ ],
+ "datasource" : "Local",
+ "lines" : false,
+ "nullPointMode" : "null",
+ "title" : "OSDs Down",
+ "stack" : false,
+ "span" : 2,
+ "seriesOverrides" : [],
+ "steppedLine" : true,
+ "aliasColors" : {},
+ "timeFrom" : "5m",
+ "type" : "graph",
+ "fill" : 2,
+ "timeShift" : null,
+ "links" : []
+ },
+ {
+ "bars" : false,
+ "description" : "This trigger raises a notification if the raw used crosses the 85% capacity threshold of the ceph cluster",
+ "thresholds" : [
+ {
+ "op" : "gt",
+ "line" : true,
+ "value" : 85,
+ "fill" : true,
+ "colorMode" : "critical"
+ }
+ ],
+ "linewidth" : 1,
+ "targets" : [
+ {
+ "hide" : true,
+ "refId" : "A",
+ "textEditor" : true,
+ "target" : "alias(maxSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.*.mon.osd_bytes,1, \"maxSeries\")), \"Raw Capacity\")"
+ },
+ {
+ "refId" : "B",
+ "hide" : true,
+ "textEditor" : true,
+ "target" : "alias(maxSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.*.mon.osd_bytes_used,1, \"maxSeries\")), \"Used Raw\")"
+ },
+ {
+ "target" : "alias(asPercent(#B, #A), \"Raw Capacity Used %\")",
+ "textEditor" : true,
+ "targetFull" : "alias(asPercent(alias(maxSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.*.mon.osd_bytes_used,1, \"maxSeries\")), \"Used Raw\"), alias(maxSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.*.mon.osd_bytes,1, \"maxSeries\")), \"Raw Capacity\")), \"Raw Capacity Used %\")",
+ "refId" : "C"
+ }
+ ],
+ "tooltip" : {
+ "shared" : true,
+ "value_type" : "individual",
+ "sort" : 0
+ },
+ "title" : "Cluster Capacity",
+ "stack" : false,
+ "seriesOverrides" : [],
+ "span" : 2,
+ "nullPointMode" : "null",
+ "lines" : true,
+ "datasource" : "Local",
+ "timeFrom" : null,
+ "type" : "graph",
+ "timeShift" : null,
+ "links" : [],
+ "fill" : 1,
+ "aliasColors" : {},
+ "steppedLine" : false,
+ "legend" : {
+ "max" : false,
+ "avg" : false,
+ "total" : false,
+ "show" : true,
+ "current" : false,
+ "values" : false,
+ "min" : false
+ },
+ "dashes" : false,
+ "percentage" : false,
+ "alert" : {
+ "name" : "Cluster Capacity",
+ "notifications" : [
+ {
+ "id" : 1
+ }
+ ],
+ "message" : "Cluster Capacity Limit Warning",
+ "conditions" : [
+ {
+ "evaluator" : {
+ "params" : [
+ 85
+ ],
+ "type" : "gt"
+ },
+ "type" : "query",
+ "query" : {
+ "params" : [
+ "C",
+ "1h",
+ "now"
+ ]
+ },
+ "reducer" : {
+ "params" : [],
+ "type" : "avg"
+ },
+ "operator" : {
+ "type" : "and"
+ }
+ }
+ ],
+ "executionErrorState" : "alerting",
+ "frequency" : "60s",
+ "handler" : 1,
+ "noDataState" : "keep_state"
+ },
+ "points" : false,
+ "id" : 5,
+ "spaceLength" : 10,
+ "minSpan" : 2,
+ "dashLength" : 10,
+ "renderer" : "flot",
+ "pointradius" : 5,
+ "xaxis" : {
+ "values" : [],
+ "name" : null,
+ "show" : true,
+ "buckets" : null,
+ "mode" : "time"
+ },
+ "yaxes" : [
+ {
+ "label" : "",
+ "show" : true,
+ "min" : "0",
+ "logBase" : 1,
+ "format" : "percent",
+ "max" : "100"
+ },
+ {
+ "logBase" : 1,
+ "min" : null,
+ "show" : false,
+ "label" : null,
+ "max" : null,
+ "format" : "short"
+ }
+ ]
+ },
+ {
+ "alert" : {
+ "executionErrorState" : "alerting",
+ "frequency" : "60s",
+ "handler" : 1,
+ "noDataState" : "no_data",
+ "notifications" : [
+ {
+ "id" : 1
+ }
+ ],
+ "name" : "PG's Stuck",
+ "message" : "PG's stuck inactive",
+ "conditions" : [
+ {
+ "evaluator" : {
+ "params" : [
+ 0
+ ],
+ "type" : "gt"
+ },
+ "type" : "query",
+ "query" : {
+ "params" : [
+ "A",
+ "1m",
+ "now"
+ ]
+ },
+ "reducer" : {
+ "type" : "last",
+ "params" : []
+ },
+ "operator" : {
+ "type" : "and"
+ }
+ }
+ ]
+ },
+ "points" : false,
+ "id" : 8,
+ "spaceLength" : 10,
+ "legend" : {
+ "max" : false,
+ "avg" : false,
+ "total" : false,
+ "show" : true,
+ "current" : false,
+ "values" : false,
+ "min" : false
+ },
+ "dashes" : false,
+ "percentage" : false,
+ "hideTimeOverride" : true,
+ "xaxis" : {
+ "mode" : "time",
+ "show" : true,
+ "buckets" : null,
+ "name" : null,
+ "values" : [
+ "total"
+ ]
+ },
+ "yaxes" : [
+ {
+ "logBase" : 1,
+ "min" : "0",
+ "show" : true,
+ "label" : null,
+ "max" : null,
+ "format" : "short"
+ },
+ {
+ "show" : false,
+ "label" : null,
+ "logBase" : 1,
+ "min" : null,
+ "max" : null,
+ "format" : "short"
+ }
+ ],
+ "dashLength" : 10,
+ "minSpan" : 2,
+ "renderer" : "flot",
+ "pointradius" : 5,
+ "thresholds" : [
+ {
+ "fill" : true,
+ "colorMode" : "critical",
+ "line" : true,
+ "op" : "gt",
+ "value" : 0
+ }
+ ],
+ "linewidth" : 2,
+ "tooltip" : {
+ "shared" : false,
+ "sort" : 0,
+ "value_type" : "individual"
+ },
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : "alias(maxSeries(consolidateBy(collectd.*.$domain.cephmetrics.gauge.*.mon.num_pgs_stuck, \"maxSeries\")), \"# pg's stuck inactive\")",
+ "textEditor" : true
+ }
+ ],
+ "bars" : false,
+ "description" : "This chart shows whether there are pg's in a stuck state, that need manual intervention to resolve.",
+ "timeFrom" : "6h",
+ "type" : "graph",
+ "links" : [],
+ "timeShift" : null,
+ "fill" : 2,
+ "aliasColors" : {},
+ "steppedLine" : false,
+ "span" : 2,
+ "title" : "PG's Stuck",
+ "stack" : false,
+ "seriesOverrides" : [],
+ "nullPointMode" : "null",
+ "lines" : true,
+ "datasource" : "Local"
+ },
+ {
+ "xaxis" : {
+ "values" : [],
+ "name" : null,
+ "show" : true,
+ "buckets" : null,
+ "mode" : "time"
+ },
+ "yaxes" : [
+ {
+ "show" : true,
+ "label" : null,
+ "logBase" : 1,
+ "min" : "0",
+ "max" : null,
+ "format" : "decbytes"
+ },
+ {
+ "show" : true,
+ "label" : null,
+ "logBase" : 1,
+ "min" : null,
+ "max" : null,
+ "format" : "short"
+ }
+ ],
+ "minSpan" : 2,
+ "dashLength" : 10,
+ "renderer" : "flot",
+ "pointradius" : 5,
+ "alert" : {
+ "noDataState" : "ok",
+ "handler" : 1,
+ "executionErrorState" : "alerting",
+ "frequency" : "60s",
+ "conditions" : [
+ {
+ "reducer" : {
+ "type" : "min",
+ "params" : []
+ },
+ "operator" : {
+ "type" : "and"
+ },
+ "query" : {
+ "params" : [
+ "A",
+ "5m",
+ "now"
+ ]
+ },
+ "type" : "query",
+ "evaluator" : {
+ "type" : "lt",
+ "params" : [
+ 0
+ ]
+ }
+ }
+ ],
+ "message" : "OSD Host Loss Free Space Check Failed",
+ "name" : "OSD Host Loss Check",
+ "notifications" : [
+ {
+ "id" : 1
+ }
+ ]
+ },
+ "spaceLength" : 10,
+ "points" : false,
+ "id" : 9,
+ "dashes" : false,
+ "legend" : {
+ "current" : false,
+ "show" : false,
+ "min" : false,
+ "values" : false,
+ "max" : false,
+ "total" : false,
+ "avg" : false
+ },
+ "percentage" : false,
+ "aliasColors" : {
+ "Largest OSD Host" : "#890F02"
+ },
+ "steppedLine" : false,
+ "timeFrom" : null,
+ "type" : "graph",
+ "timeShift" : null,
+ "links" : [],
+ "fill" : 1,
+ "lines" : true,
+ "seriesOverrides" : [],
+ "title" : "OSD Host Loss Check",
+ "stack" : false,
+ "span" : 2,
+ "nullPointMode" : "null",
+ "datasource" : "Local",
+ "thresholds" : [
+ {
+ "line" : true,
+ "op" : "lt",
+ "value" : 0,
+ "fill" : true,
+ "colorMode" : "critical"
+ }
+ ],
+ "linewidth" : 1,
+ "tooltip" : {
+ "shared" : true,
+ "sort" : 0,
+ "value_type" : "individual"
+ },
+ "targets" : [
+ {
+ "refId" : "A",
+ "hide" : true,
+ "textEditor" : true,
+ "target" : "alias(scale(maxSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.*.mon.osd_bytes_avail,1, \"maxSeries\")),0.9), \"Raw Freespace\")"
+ },
+ {
+ "target" : "alias(maxSeries(groupByNode(keepLastValue(collectd.*.$domain.cephmetrics.gauge.*.osd.*.stat_bytes),1,\"sumSeries\")), \"Largest OSD Host\")",
+ "textEditor" : true,
+ "refId" : "B",
+ "hide" : true
+ },
+ {
+ "targetFull" : "alias(diffSeries(alias(scale(maxSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.*.mon.osd_bytes_avail,1, \"maxSeries\")),0.9), \"Raw Freespace\"),alias(maxSeries(groupByNode(keepLastValue(collectd.*.$domain.cephmetrics.gauge.*.osd.*.stat_bytes),1,\"sumSeries\")), \"Largest OSD Host\")),\"freespace after Node loss\")",
+ "refId" : "C",
+ "target" : "alias(diffSeries(#A,#B),\"freespace after Node loss\")",
+ "textEditor" : true
+ }
+ ],
+ "bars" : false,
+ "description" : "This graph checks the cluster @ 90% full is enough to support the loss of the largest OSD host"
+ },
+ {
+ "renderer" : "flot",
+ "minSpan" : 2,
+ "dashLength" : 10,
+ "pointradius" : 5,
+ "xaxis" : {
+ "mode" : "time",
+ "show" : true,
+ "buckets" : null,
+ "values" : [],
+ "name" : null
+ },
+ "yaxes" : [
+ {
+ "min" : "0",
+ "logBase" : 1,
+ "label" : "ms",
+ "show" : true,
+ "format" : "none",
+ "max" : null
+ },
+ {
+ "format" : "short",
+ "max" : null,
+ "min" : null,
+ "logBase" : 1,
+ "label" : null,
+ "show" : false
+ }
+ ],
+ "legend" : {
+ "max" : false,
+ "total" : false,
+ "avg" : false,
+ "current" : false,
+ "show" : true,
+ "min" : false,
+ "values" : false
+ },
+ "dashes" : false,
+ "hideTimeOverride" : true,
+ "percentage" : false,
+ "maxDataPoints" : "",
+ "alert" : {
+ "executionErrorState" : "alerting",
+ "frequency" : "30s",
+ "handler" : 1,
+ "noDataState" : "ok",
+ "name" : "Slow OSD responses alert",
+ "notifications" : [
+ {
+ "id" : 1
+ }
+ ],
+ "message" : "OSD Response time is > 1s",
+ "conditions" : [
+ {
+ "evaluator" : {
+ "type" : "gt",
+ "params" : [
+ 1000
+ ]
+ },
+ "type" : "query",
+ "query" : {
+ "params" : [
+ "A",
+ "1m",
+ "now"
+ ]
+ },
+ "operator" : {
+ "type" : "and"
+ },
+ "reducer" : {
+ "type" : "max",
+ "params" : []
+ }
+ }
+ ]
+ },
+ "id" : 10,
+ "points" : false,
+ "spaceLength" : 10,
+ "title" : "Slow OSD responses",
+ "stack" : false,
+ "nullPointMode" : "null",
+ "span" : 2,
+ "seriesOverrides" : [],
+ "lines" : true,
+ "datasource" : "Local",
+ "timeShift" : null,
+ "fill" : 1,
+ "links" : [],
+ "timeFrom" : "1h",
+ "type" : "graph",
+ "aliasColors" : {
+ "Largest OSD Host" : "#890F02"
+ },
+ "steppedLine" : false,
+ "bars" : false,
+ "description" : "Graph checking for OSD Latencies that are above 1s.",
+ "thresholds" : [
+ {
+ "fill" : true,
+ "colorMode" : "critical",
+ "line" : true,
+ "op" : "gt",
+ "value" : 1000
+ }
+ ],
+ "targets" : [
+ {
+ "refId" : "A",
+ "textEditor" : true,
+ "target" : "aliasByNode(currentAbove(keepLastValue(transformNull(collectd.*.$domain.cephmetrics.gauge.*.osd.*.perf.await,-1)),1000),1,-3)"
+ }
+ ],
+ "tooltip" : {
+ "sort" : 0,
+ "value_type" : "individual",
+ "shared" : true
+ },
+ "linewidth" : 1
+ },
+ {
+ "thresholds" : [
+ {
+ "value" : 10,
+ "op" : "gt",
+ "line" : true,
+ "colorMode" : "critical",
+ "fill" : true
+ }
+ ],
+ "linewidth" : 1,
+ "tooltip" : {
+ "shared" : true,
+ "sort" : 0,
+ "value_type" : "individual"
+ },
+ "targets" : [
+ {
+ "target" : "groupByNode(collectd.*.$domain.interface.*.if_{dropped,errors}.*,1,\"sumSeries\")",
+ "textEditor" : true,
+ "refId" : "A"
+ }
+ ],
+ "bars" : false,
+ "description" : "Checks all interfaces for dropped/error packets, and alerts if more than 10 are seen in a 5m interval",
+ "aliasColors" : {},
+ "steppedLine" : false,
+ "type" : "graph",
+ "timeFrom" : null,
+ "fill" : 1,
+ "timeShift" : null,
+ "links" : [],
+ "lines" : true,
+ "span" : 2,
+ "title" : "Network Errors",
+ "stack" : false,
+ "seriesOverrides" : [],
+ "nullPointMode" : "null",
+ "datasource" : null,
+ "alert" : {
+ "handler" : 1,
+ "frequency" : "30s",
+ "executionErrorState" : "keep_state",
+ "noDataState" : "no_data",
+ "notifications" : [
+ {
+ "id" : 1
+ }
+ ],
+ "name" : "Network Errors alert",
+ "conditions" : [
+ {
+ "query" : {
+ "params" : [
+ "A",
+ "5m",
+ "now"
+ ]
+ },
+ "reducer" : {
+ "type" : "max",
+ "params" : []
+ },
+ "operator" : {
+ "type" : "and"
+ },
+ "evaluator" : {
+ "type" : "gt",
+ "params" : [
+ 10
+ ]
+ },
+ "type" : "query"
+ }
+ ],
+ "message" : "Network rx/tx issues detected"
+ },
+ "spaceLength" : 10,
+ "points" : false,
+ "id" : 11,
+ "dashes" : false,
+ "legend" : {
+ "min" : false,
+ "values" : false,
+ "current" : false,
+ "show" : false,
+ "total" : false,
+ "avg" : false,
+ "max" : false
+ },
+ "percentage" : false,
+ "xaxis" : {
+ "show" : true,
+ "buckets" : null,
+ "name" : null,
+ "values" : [],
+ "mode" : "time"
+ },
+ "yaxes" : [
+ {
+ "format" : "none",
+ "max" : null,
+ "label" : null,
+ "show" : true,
+ "min" : "0",
+ "logBase" : 1
+ },
+ {
+ "logBase" : 1,
+ "min" : null,
+ "show" : false,
+ "label" : null,
+ "max" : null,
+ "format" : "short"
+ }
+ ],
+ "minSpan" : 2,
+ "dashLength" : 10,
+ "renderer" : "flot",
+ "pointradius" : 5
+ }
+ ],
+ "repeatIteration" : null,
+ "repeat" : null
+ }
+ ],
+ "graphTooltip" : 0,
+ "links" : [],
+ "templating" : {
+ "list" : []
+ },
+ "tags" : [],
+ "editable" : false,
+ "title" : "Alert Status"
+ }
+}
--- /dev/null
+{
+ "meta" : {
+ "createdBy" : "admin",
+ "updatedBy" : "admin",
+ "expires" : "0001-01-01T00:00:00Z",
+ "canStar" : true,
+ "type" : "db",
+ "created" : "2017-08-03T21:42:28Z",
+ "updated" : "2017-08-19T09:36:03Z",
+ "version" : 15,
+ "slug" : "ceph-at-a-glance",
+ "isStarred" : true,
+ "canSave" : true,
+ "canEdit" : true
+ },
+ "dashboard" : {
+ "rows" : [
+ {
+ "collapse" : false,
+ "titleSize" : "h6",
+ "repeatRowId" : null,
+ "repeat" : null,
+ "panels" : [
+ {
+ "rangeMaps" : [
+ {
+ "from" : "null",
+ "text" : "N/A",
+ "to" : "null"
+ }
+ ],
+ "id" : 86,
+ "mappingType" : 1,
+ "datasource" : "Local",
+ "title" : "",
+ "minSpan" : 1,
+ "span" : 1,
+ "postfixFontSize" : "10%",
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "interval" : null,
+ "colorValue" : false,
+ "links" : [
+ {
+ "targetBlank" : true,
+ "dashboard" : "Ceph Cluster",
+ "includeVars" : true,
+ "type" : "dashboard",
+ "dashUri" : "db/ceph-cluster",
+ "title" : "Ceph Cluster",
+ "keepTime" : true
+ }
+ ],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "format" : "none",
+ "nullText" : null,
+ "postfix" : "",
+ "transparent" : true,
+ "tableColumn" : "",
+ "prefix" : "",
+ "thresholds" : "",
+ "maxDataPoints" : 100,
+ "cacheTimeout" : null,
+ "height" : "50px",
+ "type" : "singlestat",
+ "valueName" : "current",
+ "valueMaps" : [
+ {
+ "text" : "Cluster",
+ "value" : "null",
+ "op" : "="
+ }
+ ],
+ "sparkline" : {
+ "show" : false,
+ "lineColor" : "rgb(31, 120, 193)",
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)"
+ },
+ "valueFontSize" : "35%",
+ "gauge" : {
+ "maxValue" : 100,
+ "thresholdMarkers" : true,
+ "show" : false,
+ "minValue" : 0,
+ "thresholdLabels" : false
+ },
+ "nullPointMode" : "connected",
+ "targets" : [
+ {
+ "target" : "",
+ "refId" : "A"
+ }
+ ],
+ "prefixFontSize" : "10%",
+ "colorBackground" : false
+ },
+ {
+ "sparkline" : {
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "show" : false,
+ "lineColor" : "rgb(31, 120, 193)"
+ },
+ "valueFontSize" : "35%",
+ "type" : "singlestat",
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "value" : "null",
+ "text" : "Pools"
+ }
+ ],
+ "valueName" : "current",
+ "colorBackground" : false,
+ "prefixFontSize" : "10%",
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : ""
+ }
+ ],
+ "gauge" : {
+ "maxValue" : 100,
+ "show" : false,
+ "thresholdMarkers" : true,
+ "minValue" : 0,
+ "thresholdLabels" : false
+ },
+ "nullPointMode" : "connected",
+ "tableColumn" : "",
+ "prefix" : "",
+ "transparent" : true,
+ "maxDataPoints" : 100,
+ "height" : "50px",
+ "cacheTimeout" : null,
+ "thresholds" : "",
+ "links" : [
+ {
+ "targetBlank" : true,
+ "dashboard" : "Ceph Pools",
+ "includeVars" : true,
+ "title" : "Ceph Pools",
+ "keepTime" : true,
+ "type" : "dashboard",
+ "dashUri" : "db/ceph-pools"
+ }
+ ],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "interval" : null,
+ "postfixFontSize" : "10%",
+ "colorValue" : false,
+ "format" : "none",
+ "nullText" : null,
+ "postfix" : "",
+ "id" : 82,
+ "mappingType" : 1,
+ "rangeMaps" : [
+ {
+ "from" : "null",
+ "to" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "span" : 1,
+ "minSpan" : 1,
+ "datasource" : "Local",
+ "title" : ""
+ },
+ {
+ "title" : "",
+ "datasource" : "Local",
+ "minSpan" : 1,
+ "span" : 1,
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "to" : "null",
+ "from" : "null"
+ }
+ ],
+ "mappingType" : 1,
+ "id" : 91,
+ "postfix" : "",
+ "nullText" : null,
+ "format" : "none",
+ "colorValue" : false,
+ "postfixFontSize" : "10%",
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "interval" : null,
+ "links" : [
+ {
+ "keepTime" : true,
+ "title" : "Ceph OSD Information",
+ "dashUri" : "db/ceph-osd-information",
+ "type" : "dashboard",
+ "dashboard" : "Ceph OSD Information",
+ "includeVars" : true,
+ "targetBlank" : true
+ }
+ ],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "thresholds" : "",
+ "height" : "50px",
+ "cacheTimeout" : null,
+ "maxDataPoints" : 100,
+ "transparent" : true,
+ "prefix" : "",
+ "tableColumn" : "",
+ "nullPointMode" : "connected",
+ "gauge" : {
+ "minValue" : 0,
+ "thresholdLabels" : false,
+ "maxValue" : 100,
+ "show" : false,
+ "thresholdMarkers" : true
+ },
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : ""
+ }
+ ],
+ "prefixFontSize" : "10%",
+ "colorBackground" : false,
+ "valueName" : "current",
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "text" : "OSDs",
+ "value" : "null"
+ }
+ ],
+ "type" : "singlestat",
+ "valueFontSize" : "35%",
+ "sparkline" : {
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "show" : false,
+ "lineColor" : "rgb(31, 120, 193)"
+ }
+ },
+ {
+ "transparent" : true,
+ "tableColumn" : "",
+ "prefix" : "",
+ "thresholds" : "",
+ "maxDataPoints" : 100,
+ "height" : "50px",
+ "cacheTimeout" : null,
+ "type" : "singlestat",
+ "valueMaps" : [
+ {
+ "value" : "null",
+ "text" : "S3/Swift",
+ "op" : "="
+ }
+ ],
+ "valueName" : "current",
+ "sparkline" : {
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : false
+ },
+ "valueFontSize" : "35%",
+ "nullPointMode" : "connected",
+ "gauge" : {
+ "thresholdLabels" : false,
+ "minValue" : 0,
+ "thresholdMarkers" : true,
+ "show" : false,
+ "maxValue" : 100
+ },
+ "colorBackground" : false,
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : ""
+ }
+ ],
+ "prefixFontSize" : "10%",
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "to" : "null",
+ "from" : "null"
+ }
+ ],
+ "id" : 84,
+ "mappingType" : 1,
+ "datasource" : "Local",
+ "title" : "",
+ "span" : 1,
+ "minSpan" : 1,
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "interval" : null,
+ "postfixFontSize" : "10%",
+ "colorValue" : false,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "links" : [
+ {
+ "targetBlank" : true,
+ "dashboard" : "Ceph - RGW Workload",
+ "includeVars" : true,
+ "type" : "dashboard",
+ "dashUri" : "db/ceph-rgw-workload",
+ "title" : "Ceph RADOSGW Performance",
+ "keepTime" : true
+ }
+ ],
+ "nullText" : null,
+ "format" : "none",
+ "postfix" : ""
+ },
+ {
+ "rangeMaps" : [
+ {
+ "to" : "null",
+ "text" : "N/A",
+ "from" : "null"
+ }
+ ],
+ "id" : 83,
+ "mappingType" : 1,
+ "datasource" : "Local",
+ "title" : "",
+ "span" : 1,
+ "minSpan" : 1,
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "interval" : null,
+ "postfixFontSize" : "10%",
+ "colorValue" : false,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "links" : [
+ {
+ "type" : "dashboard",
+ "dashUri" : "db/ceph-backend-storage",
+ "title" : "OSD Host Performance",
+ "keepTime" : true,
+ "targetBlank" : true,
+ "dashboard" : "Ceph Backend Storage",
+ "includeVars" : true
+ }
+ ],
+ "format" : "none",
+ "nullText" : null,
+ "postfix" : "",
+ "transparent" : true,
+ "tableColumn" : "",
+ "prefix" : "",
+ "thresholds" : "",
+ "maxDataPoints" : 100,
+ "cacheTimeout" : null,
+ "height" : "50px",
+ "type" : "singlestat",
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "text" : "OSD Hosts",
+ "value" : "null"
+ }
+ ],
+ "valueName" : "current",
+ "sparkline" : {
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "show" : false,
+ "lineColor" : "rgb(31, 120, 193)"
+ },
+ "valueFontSize" : "35%",
+ "nullPointMode" : "connected",
+ "gauge" : {
+ "thresholdMarkers" : true,
+ "show" : false,
+ "maxValue" : 100,
+ "thresholdLabels" : false,
+ "minValue" : 0
+ },
+ "colorBackground" : false,
+ "prefixFontSize" : "10%",
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : ""
+ }
+ ]
+ },
+ {
+ "maxDataPoints" : 100,
+ "height" : "50px",
+ "cacheTimeout" : null,
+ "thresholds" : "",
+ "tableColumn" : "",
+ "prefix" : "",
+ "transparent" : true,
+ "colorBackground" : false,
+ "prefixFontSize" : "10%",
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : ""
+ }
+ ],
+ "nullPointMode" : "connected",
+ "gauge" : {
+ "minValue" : 0,
+ "thresholdLabels" : false,
+ "maxValue" : 100,
+ "thresholdMarkers" : true,
+ "show" : false
+ },
+ "sparkline" : {
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : false,
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)"
+ },
+ "valueFontSize" : "35%",
+ "type" : "singlestat",
+ "valueMaps" : [
+ {
+ "value" : "null",
+ "text" : "Network",
+ "op" : "="
+ }
+ ],
+ "valueName" : "current",
+ "span" : 1,
+ "minSpan" : 1,
+ "datasource" : "Local",
+ "title" : "",
+ "id" : 85,
+ "mappingType" : 1,
+ "rangeMaps" : [
+ {
+ "from" : "null",
+ "text" : "N/A",
+ "to" : "null"
+ }
+ ],
+ "nullText" : null,
+ "format" : "none",
+ "postfix" : "",
+ "links" : [
+ {
+ "keepTime" : true,
+ "title" : "Network Usage by Host",
+ "dashUri" : "db/network-usage-by-node",
+ "type" : "dashboard",
+ "dashboard" : "Network Usage by Node",
+ "includeVars" : true,
+ "targetBlank" : true
+ }
+ ],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "interval" : null,
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "postfixFontSize" : "10%",
+ "colorValue" : false
+ },
+ {
+ "minSpan" : 4,
+ "content" : "",
+ "span" : 4,
+ "title" : "",
+ "id" : 95,
+ "links" : [],
+ "type" : "text",
+ "mode" : "markdown",
+ "transparent" : true
+ },
+ {
+ "span" : 2,
+ "sortOrder" : 3,
+ "minSpan" : 2,
+ "limit" : 10,
+ "onlyAlertsOnDashboard" : false,
+ "stateFilter" : [
+ "alerting"
+ ],
+ "title" : "Active Alerts",
+ "id" : 94,
+ "show" : "current",
+ "links" : [
+ {
+ "targetBlank" : true,
+ "dashboard" : "Alert Status",
+ "type" : "dashboard",
+ "dashUri" : "db/alert-status",
+ "title" : "Alert Status"
+ }
+ ],
+ "type" : "alertlist"
+ }
+ ],
+ "height" : "145",
+ "repeatIteration" : null,
+ "showTitle" : false,
+ "title" : "Dashboard Row"
+ },
+ {
+ "title" : "At a Glance",
+ "repeatIteration" : null,
+ "showTitle" : true,
+ "height" : "225",
+ "panels" : [
+ {
+ "colorBackground" : true,
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : "consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.health),\"max\")",
+ "textEditor" : true
+ }
+ ],
+ "prefixFontSize" : "50%",
+ "description" : "Shows the overall health of the ceph cluster",
+ "nullPointMode" : "connected",
+ "gauge" : {
+ "maxValue" : 100,
+ "show" : false,
+ "thresholdMarkers" : true,
+ "minValue" : 0,
+ "thresholdLabels" : false
+ },
+ "sparkline" : {
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "show" : false,
+ "lineColor" : "rgb(31, 120, 193)"
+ },
+ "valueFontSize" : "50%",
+ "type" : "singlestat",
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "text" : "OK",
+ "value" : "0"
+ },
+ {
+ "text" : "WARN",
+ "value" : "4",
+ "op" : "="
+ },
+ {
+ "value" : "8",
+ "text" : "ERROR",
+ "op" : "="
+ }
+ ],
+ "valueName" : "current",
+ "maxDataPoints" : "",
+ "cacheTimeout" : null,
+ "thresholds" : "1,5",
+ "tableColumn" : "",
+ "prefix" : "",
+ "timeFrom" : "1m",
+ "format" : "none",
+ "timeShift" : null,
+ "nullText" : null,
+ "postfix" : "",
+ "colors" : [
+ "rgba(1, 167, 1, 1)",
+ "rgba(255,165,0, 1)",
+ "rgba(255, 0, 0, 1)"
+ ],
+ "links" : [
+ {
+ "dashboard" : "Ceph Health",
+ "includeVars" : true,
+ "targetBlank" : true,
+ "dashUri" : "db/ceph-health",
+ "type" : "dashboard",
+ "keepTime" : false,
+ "title" : "Ceph Health"
+ }
+ ],
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "interval" : null,
+ "postfixFontSize" : "50%",
+ "hideTimeOverride" : true,
+ "colorValue" : false,
+ "span" : 1,
+ "minSpan" : 1,
+ "datasource" : "Local",
+ "title" : "Health",
+ "id" : 28,
+ "mappingType" : 2,
+ "rangeMaps" : [
+ {
+ "from" : "0",
+ "to" : "1",
+ "text" : "OK"
+ },
+ {
+ "from" : "1",
+ "to" : "4",
+ "text" : "WARN"
+ },
+ {
+ "text" : "ERROR",
+ "to" : "99",
+ "from" : "5"
+ },
+ {
+ "text" : "NODATA",
+ "to" : "0",
+ "from" : "-10"
+ }
+ ]
+ },
+ {
+ "namePrefix" : "",
+ "flipCard" : false,
+ "id" : 75,
+ "displayName" : "MONs",
+ "timeFrom" : "1m",
+ "clusterName" : "MONs",
+ "span" : 1,
+ "isGrayOnNoData" : true,
+ "minSpan" : 1,
+ "title" : "",
+ "links" : [],
+ "type" : "vonage-status-panel",
+ "hideTimeOverride" : true,
+ "targets" : [
+ {
+ "displayType" : "Regular",
+ "refId" : "D",
+ "alias" : "total",
+ "target" : "alias(keepLastValue(consolidateBy(maxSeries(collectd.$mon_servers.$domain.cephmetrics.gauge.$cluster_name.mon.num_mon), \"max\")),\"total\")",
+ "valueHandler" : "Text Only",
+ "textEditor" : true,
+ "aggregation" : "Last"
+ },
+ {
+ "alias" : "quorum",
+ "refId" : "E",
+ "valueHandler" : "Threshold",
+ "warn" : "1",
+ "target" : "alias(keepLastValue(consolidateBy(maxSeries(collectd.$mon_servers.$domain.cephmetrics.gauge.$cluster_name.mon.num_mon_quorum), \"max\")),\"quorum\")",
+ "displayType" : "Regular",
+ "aggregation" : "Last",
+ "textEditor" : true,
+ "display" : true
+ },
+ {
+ "alias" : "down",
+ "refId" : "A",
+ "valueHandler" : "Threshold",
+ "warn" : "1",
+ "target" : "alias(diffSeries(#D,#E), \"down\")",
+ "displayType" : "Regular",
+ "targetFull" : "alias(diffSeries(alias(keepLastValue(consolidateBy(maxSeries(collectd.$mon_servers.$domain.cephmetrics.gauge.$cluster_name.mon.num_mon), \"max\")),\"total\"),alias(keepLastValue(consolidateBy(maxSeries(collectd.$mon_servers.$domain.cephmetrics.gauge.$cluster_name.mon.num_mon_quorum), \"max\")),\"quorum\")), \"down\")",
+ "aggregation" : "Last",
+ "textEditor" : true,
+ "display" : true
+ }
+ ],
+ "timeShift" : null,
+ "flipTime" : 5
+ },
+ {
+ "span" : 1,
+ "targets" : [
+ {
+ "refId" : "E",
+ "alias" : "total",
+ "hide" : false,
+ "valueHandler" : "Text Only",
+ "target" : "alias(keepLastValue(consolidateBy(maxSeries(collectd.$mon_servers.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd), \"max\")),\"total\")",
+ "displayType" : "Regular",
+ "textEditor" : true,
+ "aggregation" : "Last"
+ },
+ {
+ "aggregation" : "Last",
+ "textEditor" : true,
+ "displayType" : "Regular",
+ "target" : "alias(keepLastValue(consolidateBy(maxSeries(collectd.$mon_servers.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd_up), \"max\")),\"up\")",
+ "valueHandler" : "Text Only",
+ "hide" : false,
+ "alias" : "in",
+ "refId" : "F"
+ },
+ {
+ "target" : "alias(keepLastValue(consolidateBy(maxSeries(collectd.$mon_servers.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd_in), \"max\")),\"in\")",
+ "valueHandler" : "Text Only",
+ "refId" : "A",
+ "hide" : false,
+ "alias" : "up",
+ "textEditor" : true,
+ "aggregation" : "Last",
+ "displayType" : "Regular"
+ },
+ {
+ "hide" : false,
+ "alias" : "out",
+ "refId" : "B",
+ "target" : "alias(diffSeries(#F,#A), \"out\")",
+ "valueHandler" : "Text Only",
+ "displayType" : "Regular",
+ "aggregation" : "Last",
+ "targetFull" : "alias(diffSeries(alias(keepLastValue(consolidateBy(maxSeries(collectd.$mon_servers.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd_up), \"max\")),\"up\"),alias(keepLastValue(consolidateBy(maxSeries(collectd.$mon_servers.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd_in), \"max\")),\"in\")), \"out\")",
+ "textEditor" : true
+ },
+ {
+ "textEditor" : true,
+ "display" : true,
+ "targetFull" : "alias(diffSeries(alias(keepLastValue(consolidateBy(maxSeries(collectd.$mon_servers.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd), \"max\")),\"total\"),alias(keepLastValue(consolidateBy(maxSeries(collectd.$mon_servers.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd_up), \"max\")),\"up\")), \"down\")",
+ "url" : "dashboard/db/ceph-backend-storage",
+ "aggregation" : "Last",
+ "displayType" : "Regular",
+ "crit" : "3",
+ "warn" : "1",
+ "valueHandler" : "Threshold",
+ "target" : "alias(diffSeries(#E,#F), \"down\")",
+ "refId" : "D",
+ "alias" : "down",
+ "hide" : false
+ }
+ ],
+ "minSpan" : 1,
+ "title" : "",
+ "timeShift" : null,
+ "flipTime" : 5,
+ "namePrefix" : "",
+ "id" : 65,
+ "links" : [
+ {
+ "title" : "Ceph OSD Information",
+ "dashUri" : "db/ceph-osd-information",
+ "type" : "dashboard",
+ "dashboard" : "Ceph OSD Information",
+ "targetBlank" : true
+ }
+ ],
+ "flipCard" : false,
+ "hideTimeOverride" : true,
+ "timeFrom" : "1m",
+ "clusterName" : "OSDs",
+ "displayName" : "OSDs",
+ "type" : "vonage-status-panel"
+ },
+ {
+ "prefix" : "",
+ "tableColumn" : "",
+ "decimals" : 0,
+ "cacheTimeout" : null,
+ "maxDataPoints" : "",
+ "thresholds" : "",
+ "valueFontSize" : "80%",
+ "sparkline" : {
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false
+ },
+ "valueMaps" : [
+ {
+ "text" : "N/A",
+ "value" : "null",
+ "op" : "="
+ }
+ ],
+ "valueName" : "current",
+ "type" : "singlestat",
+ "colorBackground" : false,
+ "prefixFontSize" : "50%",
+ "targets" : [
+ {
+ "refId" : "A",
+ "textEditor" : true,
+ "target" : "maxSeries(consolidateBy(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd_hosts, \"max\"))"
+ }
+ ],
+ "gauge" : {
+ "minValue" : 0,
+ "thresholdLabels" : false,
+ "maxValue" : 100,
+ "thresholdMarkers" : true,
+ "show" : false
+ },
+ "nullPointMode" : "connected",
+ "mappingType" : 1,
+ "id" : 35,
+ "rangeMaps" : [
+ {
+ "from" : "null",
+ "to" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "span" : 1,
+ "minSpan" : 1,
+ "title" : "OSD Hosts",
+ "datasource" : "Local",
+ "links" : [],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "colorValue" : false,
+ "interval" : null,
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "postfixFontSize" : "50%",
+ "postfix" : "",
+ "nullText" : null,
+ "format" : "short"
+ },
+ {
+ "links" : [],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "interval" : null,
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "postfixFontSize" : "50%",
+ "colorValue" : false,
+ "format" : "short",
+ "nullText" : null,
+ "postfix" : "",
+ "id" : 33,
+ "mappingType" : 1,
+ "rangeMaps" : [
+ {
+ "from" : "null",
+ "text" : "N/A",
+ "to" : "null"
+ }
+ ],
+ "span" : 1,
+ "minSpan" : 1,
+ "datasource" : "Local",
+ "title" : "RGW Hosts",
+ "valueFontSize" : "80%",
+ "sparkline" : {
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : false
+ },
+ "type" : "singlestat",
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "text" : "0",
+ "value" : "null"
+ }
+ ],
+ "valueName" : "current",
+ "colorBackground" : false,
+ "targets" : [
+ {
+ "refId" : "A",
+ "textEditor" : true,
+ "target" : "countSeries(collectd.*.$domain.cephmetrics.derive.$cluster_name.rgw.put)"
+ }
+ ],
+ "prefixFontSize" : "50%",
+ "nullPointMode" : "connected",
+ "gauge" : {
+ "thresholdMarkers" : true,
+ "show" : false,
+ "maxValue" : 100,
+ "thresholdLabels" : false,
+ "minValue" : 0
+ },
+ "decimals" : 0,
+ "tableColumn" : "",
+ "prefix" : "",
+ "maxDataPoints" : "",
+ "cacheTimeout" : null,
+ "thresholds" : ""
+ },
+ {
+ "format" : "short",
+ "nullText" : null,
+ "postfix" : "",
+ "links" : [],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "interval" : null,
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "value" : 2,
+ "name" : "range to text"
+ }
+ ],
+ "postfixFontSize" : "50%",
+ "colorValue" : false,
+ "span" : 1,
+ "minSpan" : 1,
+ "datasource" : "Local",
+ "title" : "MDS",
+ "id" : 34,
+ "mappingType" : 1,
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "to" : "null",
+ "from" : "null"
+ }
+ ],
+ "colorBackground" : false,
+ "prefixFontSize" : "50%",
+ "targets" : [
+ {
+ "textEditor" : true,
+ "target" : "maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_mds_in)",
+ "refId" : "A"
+ }
+ ],
+ "nullPointMode" : "connected",
+ "gauge" : {
+ "show" : false,
+ "thresholdMarkers" : true,
+ "maxValue" : 100,
+ "thresholdLabels" : false,
+ "minValue" : 0
+ },
+ "valueFontSize" : "80%",
+ "sparkline" : {
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : false
+ },
+ "type" : "singlestat",
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "value" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "valueName" : "current",
+ "maxDataPoints" : 100,
+ "cacheTimeout" : null,
+ "thresholds" : "",
+ "decimals" : 0,
+ "tableColumn" : "",
+ "prefix" : ""
+ },
+ {
+ "postfixFontSize" : "40%",
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "value" : 2,
+ "name" : "range to text"
+ }
+ ],
+ "interval" : null,
+ "colorValue" : false,
+ "hideTimeOverride" : true,
+ "links" : [],
+ "colors" : [
+ "rgba(1, 167, 1, 1)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "timeShift" : null,
+ "nullText" : null,
+ "format" : "short",
+ "postfix" : "%",
+ "rangeMaps" : [
+ {
+ "from" : "null",
+ "to" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "id" : 38,
+ "mappingType" : 1,
+ "datasource" : "Local",
+ "title" : "Capacity Utilization",
+ "minSpan" : 2,
+ "span" : 2,
+ "type" : "singlestat",
+ "valueName" : "current",
+ "valueMaps" : [
+ {
+ "value" : "null",
+ "text" : "N/A",
+ "op" : "="
+ }
+ ],
+ "sparkline" : {
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false
+ },
+ "valueFontSize" : "70%",
+ "gauge" : {
+ "thresholdLabels" : false,
+ "minValue" : 0,
+ "show" : true,
+ "thresholdMarkers" : true,
+ "maxValue" : 100
+ },
+ "nullPointMode" : "connected",
+ "targets" : [
+ {
+ "target" : "alias(maxSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes, 1,\"maxSeries\")), \"raw capacity\")",
+ "textEditor" : true,
+ "hide" : true,
+ "refId" : "A"
+ },
+ {
+ "target" : "alias(maxSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used, 1,\"maxSeries\")), \"used raw\")",
+ "textEditor" : true,
+ "hide" : true,
+ "refId" : "B"
+ },
+ {
+ "refId" : "C",
+ "targetFull" : "asPercent(alias(maxSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used, 1,\"maxSeries\")), \"used raw\"),alias(maxSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes, 1,\"maxSeries\")), \"raw capacity\"))",
+ "textEditor" : true,
+ "target" : "asPercent(#B,#A)"
+ }
+ ],
+ "prefixFontSize" : "50%",
+ "colorBackground" : false,
+ "timeFrom" : "1m",
+ "decimals" : 0,
+ "tableColumn" : "",
+ "prefix" : "",
+ "thresholds" : "70,90",
+ "maxDataPoints" : 100,
+ "cacheTimeout" : null
+ },
+ {
+ "mappingType" : 1,
+ "id" : 80,
+ "rangeMaps" : [
+ {
+ "to" : "null",
+ "text" : "N/A",
+ "from" : "null"
+ }
+ ],
+ "span" : 1,
+ "minSpan" : 1,
+ "title" : "$growth_window Growth Rate",
+ "datasource" : "Local",
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "links" : [],
+ "colorValue" : false,
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "interval" : null,
+ "postfixFontSize" : "50%",
+ "postfix" : "",
+ "format" : "decbytes",
+ "nullText" : null,
+ "prefix" : "",
+ "decimals" : 1,
+ "tableColumn" : "",
+ "cacheTimeout" : null,
+ "maxDataPoints" : 100,
+ "thresholds" : "",
+ "sparkline" : {
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "show" : false,
+ "lineColor" : "rgb(31, 120, 193)"
+ },
+ "valueFontSize" : "70%",
+ "valueMaps" : [
+ {
+ "text" : "N/A",
+ "value" : "null",
+ "op" : "="
+ }
+ ],
+ "valueName" : "current",
+ "type" : "singlestat",
+ "description" : "Shows the growth rate based on osd usage over the past $growth_window.",
+ "colorBackground" : false,
+ "targets" : [
+ {
+ "textEditor" : true,
+ "target" : "alias(consolidateBy(maxSeries(timeShift(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used,\"7d\")), \"max\"),\"-$growth_window ago\")",
+ "hide" : true,
+ "refId" : "D"
+ },
+ {
+ "refId" : "E",
+ "hide" : true,
+ "textEditor" : true,
+ "target" : "alias(consolidateBy(maxSeries(timeShift(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used,\"1d\")), \"max\"),\"-1d ago\")"
+ },
+ {
+ "target" : "alias(diffSeries(#E, #D), 'Growth over last $growth_window')",
+ "textEditor" : true,
+ "targetFull" : "alias(diffSeries(alias(consolidateBy(maxSeries(timeShift(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used,\"1d\")), \"max\"),\"-1d ago\"), alias(consolidateBy(maxSeries(timeShift(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used,\"7d\")), \"max\"),\"-$growth_window ago\")), 'Growth over last $growth_window')",
+ "refId" : "C"
+ }
+ ],
+ "prefixFontSize" : "50%",
+ "nullPointMode" : "connected",
+ "gauge" : {
+ "minValue" : 0,
+ "thresholdLabels" : false,
+ "maxValue" : 100,
+ "show" : false,
+ "thresholdMarkers" : true
+ }
+ },
+ {
+ "valueMaps" : [
+ {
+ "value" : "null",
+ "text" : "N/A",
+ "op" : "="
+ }
+ ],
+ "valueName" : "current",
+ "type" : "singlestat",
+ "sparkline" : {
+ "show" : false,
+ "lineColor" : "rgb(31, 120, 193)",
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false
+ },
+ "valueFontSize" : "70%",
+ "gauge" : {
+ "minValue" : 0,
+ "thresholdLabels" : false,
+ "maxValue" : 100,
+ "show" : false,
+ "thresholdMarkers" : true
+ },
+ "nullPointMode" : "connected",
+ "description" : "Shows the estimated number of weeks left, based on consumption over the past $growth_window.",
+ "colorBackground" : false,
+ "targets" : [
+ {
+ "refId" : "A",
+ "hide" : true,
+ "textEditor" : true,
+ "target" : "alias(consolidateBy(maxSeries(timeShift(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used,\"7d\")), \"max\"),\"-$growth_window ago\")"
+ },
+ {
+ "textEditor" : true,
+ "target" : "alias(consolidateBy(maxSeries(timeShift(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used,\"1d\")), \"max\"),\"-1d ago\")",
+ "hide" : true,
+ "refId" : "B"
+ },
+ {
+ "targetFull" : "keepLastValue(diffSeries(alias(consolidateBy(maxSeries(timeShift(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used,\"1d\")), \"max\"),\"-1d ago\"), alias(consolidateBy(maxSeries(timeShift(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used,\"7d\")), \"max\"),\"-$growth_window ago\")))",
+ "target" : "keepLastValue(diffSeries(#B, #A))",
+ "textEditor" : true,
+ "hide" : true,
+ "refId" : "C"
+ },
+ {
+ "target" : "consolidateBy(minSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_avail), \"min\")",
+ "textEditor" : true,
+ "refId" : "D",
+ "hide" : true
+ },
+ {
+ "refId" : "E",
+ "hide" : false,
+ "textEditor" : true,
+ "target" : "alias(divideSeries(#D, #C), 'Weeks Left till full')",
+ "targetFull" : "alias(divideSeries(consolidateBy(minSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_avail), \"min\"), keepLastValue(diffSeries(alias(consolidateBy(maxSeries(timeShift(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used,\"1d\")), \"max\"),\"-1d ago\"), alias(consolidateBy(maxSeries(timeShift(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used,\"7d\")), \"max\"),\"-$growth_window ago\")))), 'Weeks Left till full')"
+ }
+ ],
+ "prefixFontSize" : "50%",
+ "prefix" : "",
+ "decimals" : 0,
+ "tableColumn" : "",
+ "thresholds" : "",
+ "cacheTimeout" : null,
+ "maxDataPoints" : 100,
+ "colorValue" : false,
+ "interval" : null,
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "postfixFontSize" : "50%",
+ "links" : [],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "postfix" : "",
+ "format" : "none",
+ "nullText" : null,
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "to" : "null",
+ "from" : "null"
+ },
+ {
+ "from" : "-99999",
+ "to" : "0",
+ "text" : "N/A"
+ }
+ ],
+ "mappingType" : 2,
+ "id" : 81,
+ "title" : "Weeks Remaining",
+ "datasource" : "Local",
+ "span" : 1,
+ "minSpan" : 1
+ },
+ {
+ "pieType" : "pie",
+ "datasource" : "Local",
+ "title" : "Placement Group Status",
+ "span" : 2,
+ "minSpan" : 2,
+ "maxDataPoints" : "1",
+ "cacheTimeout" : null,
+ "height" : "210",
+ "timeFrom" : "1m",
+ "legendType" : "Under graph",
+ "legend" : {
+ "values" : false,
+ "show" : true,
+ "percentage" : false
+ },
+ "id" : 74,
+ "aliasColors" : {
+ "active + clean" : "#01a701",
+ "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg_active_clean" : "#01a701",
+ "peering" : "#0A50A1",
+ "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg_peering" : "#ffa500"
+ },
+ "fontSize" : "100%",
+ "format" : "none",
+ "timeShift" : null,
+ "nullPointMode" : "connected",
+ "targets" : [
+ {
+ "textEditor" : true,
+ "target" : "alias(keepLastValue(consolidateBy(maxSeries(collectd.$mon_servers.$domain.cephmetrics.gauge.$cluster_name.mon.num_pg_active_clean), \"max\")),\"active + clean\")",
+ "refId" : "A"
+ },
+ {
+ "textEditor" : true,
+ "target" : "alias(keepLastValue(consolidateBy(maxSeries(collectd.$mon_servers.$domain.cephmetrics.gauge.$cluster_name.mon.num_pg_active), \"max\")),\"active\")",
+ "refId" : "B",
+ "hide" : true
+ },
+ {
+ "refId" : "C",
+ "targetFull" : "alias(diffSeries(alias(keepLastValue(consolidateBy(maxSeries(collectd.$mon_servers.$domain.cephmetrics.gauge.$cluster_name.mon.num_pg_active), \"max\")),\"active\"),alias(keepLastValue(consolidateBy(maxSeries(collectd.$mon_servers.$domain.cephmetrics.gauge.$cluster_name.mon.num_pg_active_clean), \"max\")),\"active + clean\")),\"active + degraded\")",
+ "textEditor" : true,
+ "target" : "alias(diffSeries(#B,#A),\"active + degraded\")"
+ },
+ {
+ "target" : "alias(consolidateBy(maxSeries(collectd.$mon_servers.$domain.cephmetrics.gauge.$cluster_name.mon.num_pg_peering), \"max\"),\"peering\")",
+ "textEditor" : true,
+ "refId" : "D",
+ "hide" : false
+ }
+ ],
+ "combine" : {
+ "label" : "Others",
+ "threshold" : ""
+ },
+ "strokeWidth" : "0",
+ "interval" : null,
+ "type" : "grafana-piechart-panel",
+ "hideTimeOverride" : true,
+ "valueName" : "current",
+ "links" : [
+ {
+ "dashboard" : "Ceph Cluster",
+ "includeVars" : false,
+ "targetBlank" : true,
+ "keepTime" : false,
+ "title" : "Ceph Cluster Information",
+ "dashUri" : "db/ceph-cluster",
+ "type" : "dashboard"
+ }
+ ]
+ }
+ ],
+ "titleSize" : "h5",
+ "collapse" : false,
+ "repeat" : null,
+ "repeatRowId" : null
+ },
+ {
+ "title" : "Performance",
+ "height" : "230",
+ "repeatIteration" : null,
+ "showTitle" : false,
+ "panels" : [
+ {
+ "prefixFontSize" : "50%",
+ "targets" : [
+ {
+ "refId" : "A",
+ "hide" : true,
+ "target" : "consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.deep_scrub),\"max\")",
+ "textEditor" : true
+ },
+ {
+ "textEditor" : true,
+ "target" : "consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.scrub),\"max\")",
+ "hide" : true,
+ "refId" : "B"
+ },
+ {
+ "targetFull" : "maxSeries(group(consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.deep_scrub),\"max\"), consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.scrub),\"max\")))",
+ "target" : "maxSeries(group(#A, #B))",
+ "textEditor" : true,
+ "refId" : "C"
+ }
+ ],
+ "colorBackground" : true,
+ "description" : "This panel indicate whether scrub/deep scrub is running within the cluster. NB. If either of these features are turned off, the cluster will enter a WARN state. Click on the panel or the link below to look at cluster information in more detail",
+ "gauge" : {
+ "maxValue" : 100,
+ "thresholdMarkers" : true,
+ "show" : false,
+ "minValue" : 0,
+ "thresholdLabels" : false
+ },
+ "nullPointMode" : "connected",
+ "valueFontSize" : "50%",
+ "sparkline" : {
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "show" : false,
+ "lineColor" : "rgb(31, 120, 193)"
+ },
+ "type" : "singlestat",
+ "valueName" : "current",
+ "valueMaps" : [
+ {
+ "value" : "null",
+ "text" : "N/A",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "value" : "0",
+ "text" : "INACTIVE"
+ },
+ {
+ "op" : "=",
+ "value" : "1",
+ "text" : "ACTIVE"
+ },
+ {
+ "op" : "=",
+ "text" : "DISABLED",
+ "value" : "2"
+ }
+ ],
+ "maxDataPoints" : "",
+ "cacheTimeout" : null,
+ "thresholds" : "2",
+ "tableColumn" : "",
+ "prefix" : "",
+ "format" : "none",
+ "nullText" : null,
+ "postfix" : "",
+ "colors" : [
+ "rgba(251,251,251, 0.97)",
+ "rgba(255,0,0,1)",
+ "rgba(255, 0, 0, 1)"
+ ],
+ "links" : [
+ {
+ "keepTime" : false,
+ "title" : "Ceph Cluster",
+ "dashUri" : "db/ceph-cluster",
+ "type" : "dashboard",
+ "dashboard" : "Ceph Cluster",
+ "includeVars" : false,
+ "targetBlank" : true
+ }
+ ],
+ "postfixFontSize" : "50%",
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "interval" : null,
+ "colorValue" : false,
+ "minSpan" : 1,
+ "span" : 1,
+ "datasource" : "Local",
+ "title" : "Scrub",
+ "id" : 97,
+ "mappingType" : 1,
+ "rangeMaps" : [
+ {
+ "from" : "null",
+ "text" : "N/A",
+ "to" : "null"
+ }
+ ]
+ },
+ {
+ "thresholds" : "1,2",
+ "cacheTimeout" : null,
+ "maxDataPoints" : "90",
+ "prefix" : "",
+ "tableColumn" : "",
+ "decimals" : 1,
+ "nullPointMode" : "connected",
+ "gauge" : {
+ "show" : false,
+ "thresholdMarkers" : true,
+ "maxValue" : 100,
+ "thresholdLabels" : false,
+ "minValue" : 0
+ },
+ "targets" : [
+ {
+ "target" : "sumSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.*.recovering_bytes_per_sec,-2,\"avg\"))",
+ "textEditor" : true,
+ "refId" : "A"
+ }
+ ],
+ "prefixFontSize" : "50%",
+ "colorBackground" : false,
+ "valueName" : "current",
+ "valueMaps" : [
+ {
+ "text" : "N/A",
+ "value" : "null",
+ "op" : "="
+ }
+ ],
+ "type" : "singlestat",
+ "sparkline" : {
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "show" : true,
+ "lineColor" : "rgb(31, 120, 193)"
+ },
+ "valueFontSize" : "50%",
+ "title" : "Recovery",
+ "datasource" : "Local",
+ "minSpan" : 1,
+ "span" : 1,
+ "rangeMaps" : [
+ {
+ "from" : "null",
+ "to" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "mappingType" : 1,
+ "id" : 96,
+ "postfix" : "/s",
+ "nullText" : null,
+ "format" : "decbytes",
+ "colorValue" : false,
+ "postfixFontSize" : "50%",
+ "interval" : null,
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "links" : [
+ {
+ "includeVars" : true,
+ "dashboard" : "Ceph Pools",
+ "targetBlank" : true,
+ "dashUri" : "db/ceph-pools",
+ "type" : "dashboard",
+ "keepTime" : true,
+ "title" : "Ceph Pools"
+ }
+ ],
+ "colors" : [
+ "rgba(251,251,251, 0.97)",
+ "rgba(255,165,0, 0.89)",
+ "rgba(255, 0, 0, 1)"
+ ]
+ },
+ {
+ "postfix" : "",
+ "format" : "none",
+ "nullText" : null,
+ "links" : [
+ {
+ "dashboard" : "Ceph Pools",
+ "includeVars" : true,
+ "targetBlank" : true,
+ "dashUri" : "db/ceph-pools",
+ "type" : "dashboard",
+ "keepTime" : true,
+ "title" : "Ceph Pools"
+ }
+ ],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "colorValue" : false,
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "value" : 2,
+ "name" : "range to text"
+ }
+ ],
+ "interval" : null,
+ "postfixFontSize" : "50%",
+ "span" : 2,
+ "minSpan" : 2,
+ "title" : "Client IOPS",
+ "datasource" : "Local",
+ "mappingType" : 1,
+ "id" : 9,
+ "rangeMaps" : [
+ {
+ "from" : "null",
+ "text" : "N/A",
+ "to" : "null"
+ }
+ ],
+ "colorBackground" : false,
+ "prefixFontSize" : "50%",
+ "targets" : [
+ {
+ "query" : "SELECT mean(\"value\") FROM \"measurement\" WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "groupBy" : [],
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "textEditor" : true,
+ "tags" : [],
+ "select" : [
+ [
+ {
+ "type" : "field",
+ "params" : [
+ "value"
+ ]
+ }
+ ]
+ ],
+ "resultFormat" : "time_series",
+ "policy" : "default",
+ "refId" : "A",
+ "rawQuery" : false,
+ "hide" : false,
+ "target" : "sumSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.*.op_per_sec,-2,\"maxSeries\"))",
+ "dsType" : "influxdb"
+ }
+ ],
+ "gauge" : {
+ "minValue" : 0,
+ "thresholdLabels" : false,
+ "maxValue" : 100,
+ "show" : false,
+ "thresholdMarkers" : true
+ },
+ "nullPointMode" : "connected",
+ "sparkline" : {
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : true
+ },
+ "valueFontSize" : "100%",
+ "valueMaps" : [
+ {
+ "text" : "N/A",
+ "value" : "null",
+ "op" : "="
+ }
+ ],
+ "valueName" : "current",
+ "type" : "singlestat",
+ "cacheTimeout" : null,
+ "maxDataPoints" : "90",
+ "thresholds" : "",
+ "prefix" : "",
+ "decimals" : 0,
+ "tableColumn" : ""
+ },
+ {
+ "valueName" : "current",
+ "valueMaps" : [
+ {
+ "text" : "N/A",
+ "value" : "null",
+ "op" : "="
+ }
+ ],
+ "type" : "singlestat",
+ "valueFontSize" : "70%",
+ "sparkline" : {
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "show" : true,
+ "lineColor" : "rgb(31, 120, 193)"
+ },
+ "gauge" : {
+ "maxValue" : 100,
+ "thresholdMarkers" : true,
+ "show" : false,
+ "minValue" : 0,
+ "thresholdLabels" : false
+ },
+ "nullPointMode" : "connected",
+ "targets" : [
+ {
+ "dsType" : "influxdb",
+ "target" : "sumSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.*.bytes_sec,-2,\"maxSeries\"))",
+ "hide" : false,
+ "rawQuery" : true,
+ "refId" : "A",
+ "policy" : "default",
+ "select" : [
+ [
+ {
+ "type" : "field",
+ "params" : [
+ "value"
+ ]
+ }
+ ]
+ ],
+ "tags" : [],
+ "resultFormat" : "time_series",
+ "textEditor" : true,
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "groupBy" : [],
+ "query" : "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_bytes_sec\" WHERE $timeFilter"
+ }
+ ],
+ "prefixFontSize" : "50%",
+ "colorBackground" : false,
+ "prefix" : "",
+ "decimals" : 1,
+ "tableColumn" : "",
+ "thresholds" : "",
+ "cacheTimeout" : null,
+ "maxDataPoints" : "90",
+ "colorValue" : false,
+ "postfixFontSize" : "50%",
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "interval" : null,
+ "links" : [
+ {
+ "targetBlank" : true,
+ "includeVars" : true,
+ "dashboard" : "Ceph Pools",
+ "title" : "Ceph Pools",
+ "keepTime" : true,
+ "type" : "dashboard",
+ "dashUri" : "db/ceph-pools"
+ }
+ ],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "postfix" : "/s",
+ "nullText" : null,
+ "format" : "decbytes",
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "to" : "null",
+ "from" : "null"
+ }
+ ],
+ "mappingType" : 1,
+ "id" : 23,
+ "title" : "Client Throughput",
+ "datasource" : "Local",
+ "minSpan" : 2,
+ "span" : 2
+ },
+ {
+ "type" : "singlestat",
+ "valueName" : "current",
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "text" : "N/A",
+ "value" : "null"
+ }
+ ],
+ "valueFontSize" : "70%",
+ "sparkline" : {
+ "show" : false,
+ "lineColor" : "rgb(31, 120, 193)",
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false
+ },
+ "nullPointMode" : "connected",
+ "gauge" : {
+ "thresholdLabels" : false,
+ "minValue" : 0,
+ "show" : false,
+ "thresholdMarkers" : true,
+ "maxValue" : 100
+ },
+ "prefixFontSize" : "50%",
+ "targets" : [
+ {
+ "policy" : "default",
+ "refId" : "A",
+ "target" : "maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_pool)",
+ "dsType" : "influxdb",
+ "select" : [
+ [
+ {
+ "type" : "field",
+ "params" : [
+ "value"
+ ]
+ }
+ ]
+ ],
+ "tags" : [],
+ "resultFormat" : "time_series",
+ "groupBy" : [],
+ "textEditor" : true,
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pool"
+ }
+ ],
+ "colorBackground" : false,
+ "decimals" : 0,
+ "tableColumn" : "",
+ "prefix" : "",
+ "thresholds" : "",
+ "maxDataPoints" : 100,
+ "cacheTimeout" : null,
+ "postfixFontSize" : "50%",
+ "interval" : null,
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "colorValue" : false,
+ "links" : [],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "nullText" : null,
+ "format" : "short",
+ "postfix" : "",
+ "rangeMaps" : [
+ {
+ "from" : "null",
+ "to" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "id" : 76,
+ "mappingType" : 1,
+ "datasource" : "Local",
+ "title" : "Pools",
+ "minSpan" : 1,
+ "span" : 1
+ },
+ {
+ "prefix" : "",
+ "decimals" : 0,
+ "tableColumn" : "",
+ "thresholds" : "",
+ "cacheTimeout" : null,
+ "maxDataPoints" : 100,
+ "valueMaps" : [],
+ "valueName" : "current",
+ "type" : "singlestat",
+ "valueFontSize" : "70%",
+ "sparkline" : {
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : false,
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)"
+ },
+ "nullPointMode" : "connected",
+ "gauge" : {
+ "maxValue" : 100,
+ "thresholdMarkers" : true,
+ "show" : false,
+ "minValue" : 0,
+ "thresholdLabels" : false
+ },
+ "colorBackground" : false,
+ "targets" : [
+ {
+ "refId" : "B",
+ "textEditor" : true,
+ "target" : "alias(sumSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_rbds,6),\"max\")),\"# rbds\")"
+ }
+ ],
+ "prefixFontSize" : "50%",
+ "rangeMaps" : [
+ {
+ "to" : "null",
+ "text" : "N/A",
+ "from" : "null"
+ }
+ ],
+ "mappingType" : 1,
+ "id" : 77,
+ "title" : "RBDs",
+ "datasource" : "Local",
+ "span" : 1,
+ "minSpan" : 1,
+ "colorValue" : false,
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "value" : 2,
+ "name" : "range to text"
+ }
+ ],
+ "interval" : null,
+ "postfixFontSize" : "50%",
+ "links" : [],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "postfix" : "",
+ "format" : "short",
+ "nullText" : null
+ },
+ {
+ "legend" : {
+ "percentage" : false,
+ "show" : true,
+ "values" : false
+ },
+ "legendType" : "Under graph",
+ "fontSize" : "80%",
+ "aliasColors" : {
+ "Writes" : "#82B5D8",
+ "Reads" : "#01a701"
+ },
+ "id" : 93,
+ "title" : "Client Read/Write Ratio",
+ "datasource" : "Local",
+ "pieType" : "pie",
+ "cacheTimeout" : null,
+ "height" : "230",
+ "minSpan" : 2,
+ "maxDataPoints" : "90",
+ "span" : 2,
+ "valueName" : "current",
+ "type" : "grafana-piechart-panel",
+ "interval" : null,
+ "links" : [],
+ "nullPointMode" : "connected",
+ "format" : "none",
+ "description" : "Shows the read/write threshold of client IOPS serviced by the ceph cluster",
+ "strokeWidth" : 1,
+ "targets" : [
+ {
+ "refId" : "A",
+ "textEditor" : true,
+ "target" : "alias(sumSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.*.read_op_per_sec,-2,\"maxSeries\")), \"Reads\")"
+ },
+ {
+ "textEditor" : true,
+ "target" : "alias(sumSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.*.write_op_per_sec,-2,\"maxSeries\")), \"Writes\")",
+ "refId" : "B"
+ }
+ ],
+ "combine" : {
+ "label" : "Others",
+ "threshold" : 0
+ }
+ },
+ {
+ "renderer" : "flot",
+ "seriesOverrides" : [],
+ "pointradius" : 5,
+ "id" : 92,
+ "stack" : false,
+ "dashLength" : 10,
+ "title" : "OSD Apply vs Commit Latency",
+ "datasource" : "Local",
+ "minSpan" : 2,
+ "span" : 2,
+ "yaxes" : [
+ {
+ "label" : null,
+ "logBase" : 1,
+ "max" : null,
+ "show" : true,
+ "min" : "0",
+ "format" : "s"
+ },
+ {
+ "show" : false,
+ "max" : null,
+ "label" : null,
+ "logBase" : 1,
+ "format" : "short",
+ "min" : null
+ }
+ ],
+ "hideTimeOverride" : true,
+ "fill" : 0,
+ "percentage" : false,
+ "links" : [
+ {
+ "dashUri" : "db/ceph-osd-information",
+ "type" : "dashboard",
+ "keepTime" : true,
+ "title" : "Ceph OSD Information",
+ "includeVars" : true,
+ "dashboard" : "Ceph OSD Information",
+ "targetBlank" : true
+ }
+ ],
+ "linewidth" : 2,
+ "steppedLine" : false,
+ "lines" : true,
+ "timeShift" : null,
+ "bars" : false,
+ "xaxis" : {
+ "name" : null,
+ "show" : false,
+ "values" : [],
+ "mode" : "time",
+ "buckets" : null
+ },
+ "tooltip" : {
+ "value_type" : "individual",
+ "sort" : 0,
+ "shared" : true
+ },
+ "legend" : {
+ "avg" : false,
+ "values" : false,
+ "total" : false,
+ "show" : true,
+ "alignAsTable" : false,
+ "rightSide" : false,
+ "current" : false,
+ "max" : false,
+ "min" : false
+ },
+ "timeFrom" : "15m",
+ "spaceLength" : 10,
+ "aliasColors" : {
+ "Commit Latency" : "#447EBC",
+ "95%ile Commit Latency" : "#447EBC",
+ "Apply Latency Max" : "#890F02"
+ },
+ "dashes" : false,
+ "thresholds" : [],
+ "type" : "graph",
+ "nullPointMode" : "null as zero",
+ "points" : false,
+ "description" : "Shows the OSD apply and commit latency at the $percentile%ile across the cluster over the past 15 minutes",
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : "alias(percentileOfSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.apply_latency,$percentile), \"Apply Latency\")",
+ "textEditor" : true
+ },
+ {
+ "target" : "alias(percentileOfSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.commitcycle_latency, $percentile), \"Commit Latency\")",
+ "textEditor" : true,
+ "refId" : "B"
+ }
+ ]
+ }
+ ],
+ "repeatRowId" : null,
+ "repeat" : null,
+ "collapse" : false,
+ "titleSize" : "h5"
+ },
+ {
+ "collapse" : false,
+ "titleSize" : "h6",
+ "repeat" : null,
+ "repeatRowId" : null,
+ "panels" : [
+ {
+ "postfix" : " %",
+ "nullText" : null,
+ "format" : "short",
+ "links" : [],
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "colorValue" : false,
+ "postfixFontSize" : "50%",
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "interval" : null,
+ "minSpan" : 2,
+ "span" : 2,
+ "title" : "OSD Hosts CPU Busy",
+ "datasource" : "Local",
+ "mappingType" : 1,
+ "id" : 59,
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "to" : "null",
+ "from" : "null"
+ }
+ ],
+ "description" : "CPU usage is presented based on the $percentile%ile across all OSD hosts",
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : "percentileOfSeries(groupByNode(collectd.$osd_servers.$domain.cpu.percent.{system,user,wait},1,\"sumSeries\"),$percentile)",
+ "textEditor" : true
+ }
+ ],
+ "prefixFontSize" : "50%",
+ "colorBackground" : false,
+ "nullPointMode" : "connected",
+ "gauge" : {
+ "thresholdLabels" : false,
+ "minValue" : 0,
+ "show" : false,
+ "thresholdMarkers" : true,
+ "maxValue" : 100
+ },
+ "sparkline" : {
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : true,
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)"
+ },
+ "valueFontSize" : "100%",
+ "valueName" : "current",
+ "valueMaps" : [
+ {
+ "text" : "N/A",
+ "value" : "null",
+ "op" : "="
+ }
+ ],
+ "type" : "singlestat",
+ "cacheTimeout" : null,
+ "maxDataPoints" : "90",
+ "thresholds" : "70,90",
+ "prefix" : "",
+ "decimals" : 0,
+ "tableColumn" : ""
+ },
+ {
+ "format" : "none",
+ "nullText" : null,
+ "postfix" : "",
+ "links" : [
+ {
+ "dashUri" : "db/ceph-backend-storage",
+ "type" : "dashboard",
+ "keepTime" : true,
+ "title" : "Ceph OSD Host Performance",
+ "includeVars" : true,
+ "dashboard" : "Ceph Backend Storage",
+ "targetBlank" : true
+ }
+ ],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "postfixFontSize" : "50%",
+ "interval" : null,
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "value" : 2,
+ "name" : "range to text"
+ }
+ ],
+ "colorValue" : false,
+ "minSpan" : 2,
+ "span" : 2,
+ "datasource" : "Local",
+ "title" : "Disk IOPS",
+ "id" : 72,
+ "mappingType" : 1,
+ "rangeMaps" : [
+ {
+ "from" : "null",
+ "to" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "targets" : [
+ {
+ "select" : [
+ [
+ {
+ "type" : "field",
+ "params" : [
+ "value"
+ ]
+ }
+ ]
+ ],
+ "tags" : [],
+ "resultFormat" : "time_series",
+ "groupBy" : [],
+ "textEditor" : true,
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "query" : "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_bytes_sec\" WHERE $timeFilter",
+ "target" : "alias(sumSeries(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.iops),\"IOPS\")",
+ "dsType" : "influxdb",
+ "rawQuery" : true,
+ "hide" : false,
+ "policy" : "default",
+ "refId" : "A"
+ }
+ ],
+ "prefixFontSize" : "50%",
+ "colorBackground" : false,
+ "description" : "Total IOPS from all OSDs in the cluster",
+ "gauge" : {
+ "minValue" : 0,
+ "thresholdLabels" : false,
+ "maxValue" : 100,
+ "thresholdMarkers" : true,
+ "show" : false
+ },
+ "nullPointMode" : "connected",
+ "sparkline" : {
+ "show" : true,
+ "lineColor" : "rgb(31, 120, 193)",
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)"
+ },
+ "valueFontSize" : "100%",
+ "type" : "singlestat",
+ "valueName" : "current",
+ "valueMaps" : [
+ {
+ "text" : "N/A",
+ "value" : "null",
+ "op" : "="
+ }
+ ],
+ "maxDataPoints" : "90",
+ "cacheTimeout" : null,
+ "thresholds" : "",
+ "tableColumn" : "",
+ "decimals" : 0,
+ "prefix" : ""
+ },
+ {
+ "colorBackground" : false,
+ "targets" : [
+ {
+ "query" : "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_bytes_sec\" WHERE $timeFilter",
+ "tags" : [],
+ "select" : [
+ [
+ {
+ "type" : "field",
+ "params" : [
+ "value"
+ ]
+ }
+ ]
+ ],
+ "resultFormat" : "time_series",
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "textEditor" : true,
+ "groupBy" : [],
+ "hide" : false,
+ "rawQuery" : true,
+ "refId" : "A",
+ "policy" : "default",
+ "dsType" : "influxdb",
+ "target" : "sumSeries(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.bytes_per_sec)"
+ }
+ ],
+ "prefixFontSize" : "50%",
+ "nullPointMode" : "connected",
+ "gauge" : {
+ "thresholdLabels" : false,
+ "minValue" : 0,
+ "show" : false,
+ "thresholdMarkers" : true,
+ "maxValue" : 100
+ },
+ "sparkline" : {
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : true
+ },
+ "valueFontSize" : "70%",
+ "type" : "singlestat",
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "value" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "valueName" : "current",
+ "maxDataPoints" : "90",
+ "cacheTimeout" : null,
+ "thresholds" : "",
+ "decimals" : 1,
+ "tableColumn" : "",
+ "prefix" : "",
+ "format" : "decbytes",
+ "nullText" : null,
+ "postfix" : "/s",
+ "links" : [
+ {
+ "targetBlank" : true,
+ "includeVars" : true,
+ "dashboard" : "Ceph Backend Storage",
+ "type" : "dashboard",
+ "dashUri" : "db/ceph-backend-storage",
+ "title" : "Ceph OSD Host Performance",
+ "keepTime" : true
+ }
+ ],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "value" : 2,
+ "name" : "range to text"
+ }
+ ],
+ "interval" : null,
+ "postfixFontSize" : "50%",
+ "colorValue" : false,
+ "span" : 2,
+ "minSpan" : 2,
+ "datasource" : "Local",
+ "title" : "Disk Throughput",
+ "id" : 73,
+ "mappingType" : 1,
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "to" : "null",
+ "from" : "null"
+ }
+ ]
+ },
+ {
+ "colorValue" : false,
+ "postfixFontSize" : "50%",
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "value" : 2,
+ "name" : "range to text"
+ }
+ ],
+ "interval" : null,
+ "links" : [
+ {
+ "dashboard" : "Ceph Backend Storage",
+ "includeVars" : true,
+ "targetBlank" : true,
+ "keepTime" : true,
+ "title" : "Ceph OSD Host Performance",
+ "dashUri" : "db/ceph-backend-storage",
+ "type" : "dashboard"
+ }
+ ],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "postfix" : "",
+ "nullText" : null,
+ "format" : "short",
+ "rangeMaps" : [
+ {
+ "to" : "null",
+ "text" : "N/A",
+ "from" : "null"
+ }
+ ],
+ "mappingType" : 1,
+ "id" : 79,
+ "title" : "Nearly Full Disks",
+ "datasource" : "Local",
+ "minSpan" : 1,
+ "span" : 1,
+ "valueName" : "current",
+ "valueMaps" : [
+ {
+ "text" : "0",
+ "value" : "null",
+ "op" : "="
+ }
+ ],
+ "type" : "singlestat",
+ "sparkline" : {
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : false,
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)"
+ },
+ "valueFontSize" : "80%",
+ "nullPointMode" : "connected",
+ "gauge" : {
+ "maxValue" : 100,
+ "show" : false,
+ "thresholdMarkers" : true,
+ "minValue" : 0,
+ "thresholdLabels" : false
+ },
+ "description" : "The count of the number of disks in the cluster that are over $disk_full_threshold% full.",
+ "prefixFontSize" : "50%",
+ "targets" : [
+ {
+ "target" : "countSeries(currentAbove(transformNull(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.osd_percent_used),0),$disk_full_threshold))",
+ "textEditor" : true,
+ "refId" : "A"
+ }
+ ],
+ "colorBackground" : false,
+ "prefix" : "",
+ "decimals" : 0,
+ "tableColumn" : "",
+ "thresholds" : "",
+ "cacheTimeout" : null,
+ "maxDataPoints" : 100
+ },
+ {
+ "title" : "RAM Util.",
+ "datasource" : "Local",
+ "minSpan" : 1,
+ "span" : 1,
+ "rangeMaps" : [
+ {
+ "to" : "null",
+ "text" : "N/A",
+ "from" : "null"
+ }
+ ],
+ "mappingType" : 1,
+ "id" : 78,
+ "postfix" : " %",
+ "nullText" : null,
+ "format" : "short",
+ "colorValue" : false,
+ "postfixFontSize" : "50%",
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "interval" : null,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "links" : [
+ {
+ "targetBlank" : true,
+ "dashboard" : "Ceph Backend Storage",
+ "includeVars" : true,
+ "title" : "Ceph OSD Host Performance",
+ "keepTime" : true,
+ "type" : "dashboard",
+ "dashUri" : "db/ceph-backend-storage"
+ }
+ ],
+ "thresholds" : "",
+ "cacheTimeout" : null,
+ "maxDataPoints" : "",
+ "prefix" : "",
+ "decimals" : 0,
+ "tableColumn" : "",
+ "gauge" : {
+ "show" : false,
+ "thresholdMarkers" : true,
+ "maxValue" : 100,
+ "thresholdLabels" : false,
+ "minValue" : 0
+ },
+ "nullPointMode" : "connected",
+ "description" : "RAM Usage shows the $percentile%ile of RAM used across all OSD hosts",
+ "targets" : [
+ {
+ "target" : "percentileOfSeries(collectd.$osd_servers.$domain.memory.percent.used,$percentile)",
+ "dsType" : "influxdb",
+ "policy" : "default",
+ "refId" : "A",
+ "rawQuery" : true,
+ "hide" : false,
+ "groupBy" : [],
+ "textEditor" : true,
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_op_per_sec",
+ "select" : [
+ [
+ {
+ "type" : "field",
+ "params" : [
+ "value"
+ ]
+ }
+ ]
+ ],
+ "tags" : [],
+ "resultFormat" : "time_series",
+ "query" : "SELECT \"value\" FROM \"collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.pools._all_.read_bytes_sec\" WHERE $timeFilter"
+ }
+ ],
+ "prefixFontSize" : "50%",
+ "colorBackground" : false,
+ "valueName" : "current",
+ "valueMaps" : [
+ {
+ "value" : "null",
+ "text" : "N/A",
+ "op" : "="
+ }
+ ],
+ "type" : "singlestat",
+ "valueFontSize" : "70%",
+ "sparkline" : {
+ "full" : false,
+ "fillColor" : "rgba(46, 161, 15, 0)",
+ "show" : false,
+ "lineColor" : "rgb(164, 139, 4)"
+ }
+ },
+ {
+ "prefix" : "",
+ "decimals" : 0,
+ "tableColumn" : "",
+ "thresholds" : "20,60",
+ "cacheTimeout" : null,
+ "maxDataPoints" : "90",
+ "valueName" : "current",
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "value" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "type" : "singlestat",
+ "sparkline" : {
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "show" : true,
+ "lineColor" : "rgb(31, 120, 193)"
+ },
+ "valueFontSize" : "100%",
+ "nullPointMode" : "connected",
+ "gauge" : {
+ "show" : false,
+ "thresholdMarkers" : true,
+ "maxValue" : 100,
+ "thresholdLabels" : false,
+ "minValue" : 0
+ },
+ "description" : "This panel shows the $percentile%ile disk await time across all OSDs in the cliuster",
+ "prefixFontSize" : "50%",
+ "targets" : [
+ {
+ "refId" : "A",
+ "textEditor" : true,
+ "target" : "percentileOfSeries(group(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.await),$percentile)"
+ }
+ ],
+ "colorBackground" : false,
+ "rangeMaps" : [
+ {
+ "to" : "null",
+ "text" : "N/A",
+ "from" : "null"
+ }
+ ],
+ "mappingType" : 1,
+ "id" : 36,
+ "title" : "Disk Latency",
+ "datasource" : "Local",
+ "minSpan" : 2,
+ "span" : 2,
+ "colorValue" : false,
+ "postfixFontSize" : "50%",
+ "interval" : null,
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "links" : [
+ {
+ "dashboard" : "Latency by Server",
+ "includeVars" : true,
+ "targetBlank" : true,
+ "dashUri" : "db/latency-by-server",
+ "type" : "dashboard",
+ "title" : "Latency by Server"
+ }
+ ],
+ "colors" : [
+ "rgba(1, 167, 1,1)",
+ "rgba(255,165,0,1)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "postfix" : " ms",
+ "nullText" : null,
+ "format" : "short"
+ },
+ {
+ "span" : 2,
+ "minSpan" : 2,
+ "title" : "Disk Utilization",
+ "datasource" : "Local",
+ "pointradius" : 5,
+ "seriesOverrides" : [
+ {
+ "alias" : "%util @ 95%ile",
+ "fill" : 0
+ }
+ ],
+ "stack" : false,
+ "dashLength" : 10,
+ "id" : 98,
+ "renderer" : "flot",
+ "bars" : false,
+ "tooltip" : {
+ "shared" : true,
+ "value_type" : "individual",
+ "sort" : 0
+ },
+ "xaxis" : {
+ "values" : [],
+ "show" : true,
+ "name" : null,
+ "buckets" : null,
+ "mode" : "time"
+ },
+ "steppedLine" : false,
+ "timeShift" : null,
+ "lines" : true,
+ "linewidth" : 2,
+ "percentage" : false,
+ "links" : [
+ {
+ "targetBlank" : true,
+ "dashboard" : "Disk Busy by Server",
+ "includeVars" : true,
+ "title" : "Disk Busy by Server",
+ "type" : "dashboard",
+ "dashUri" : "db/disk-busy-by-server"
+ }
+ ],
+ "hideTimeOverride" : true,
+ "yaxes" : [
+ {
+ "format" : "percent",
+ "min" : "0",
+ "show" : true,
+ "max" : "100",
+ "logBase" : 1,
+ "label" : ""
+ },
+ {
+ "format" : "short",
+ "min" : null,
+ "show" : true,
+ "max" : null,
+ "logBase" : 1,
+ "label" : null
+ }
+ ],
+ "fill" : 1,
+ "dashes" : false,
+ "thresholds" : [],
+ "aliasColors" : {
+ "average %util" : "#1f78c1"
+ },
+ "timeFrom" : "15m",
+ "spaceLength" : 10,
+ "legend" : {
+ "min" : false,
+ "total" : false,
+ "show" : true,
+ "current" : false,
+ "max" : false,
+ "avg" : false,
+ "values" : false
+ },
+ "description" : "Chart shows the disk utilization over the past 15 mins expressed as an average across all OSDs, and at the $percentile%ile.",
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : "alias(averageSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.util), 'average %util')",
+ "textEditor" : false
+ },
+ {
+ "target" : "alias(percentileOfSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.util, $percentile, 'false'), '%util @ $percentile%ile')",
+ "refId" : "B"
+ }
+ ],
+ "points" : false,
+ "nullPointMode" : "null",
+ "type" : "graph"
+ }
+ ],
+ "height" : "230px",
+ "repeatIteration" : null,
+ "showTitle" : false,
+ "title" : "Dashboard Row"
+ }
+ ],
+ "schemaVersion" : 14,
+ "version" : 15,
+ "refresh" : "10s",
+ "hideControls" : true,
+ "gnetId" : null,
+ "templating" : {
+ "list" : [
+ {
+ "label" : "Cluster Name",
+ "query" : "collectd.*.$domain.cephmetrics.gauge.*",
+ "tags" : [],
+ "tagValuesQuery" : "",
+ "multi" : false,
+ "includeAll" : false,
+ "tagsQuery" : "",
+ "datasource" : "Local",
+ "current" : {
+ "text" : "ceph",
+ "value" : "ceph"
+ },
+ "name" : "cluster_name",
+ "options" : [],
+ "useTags" : false,
+ "type" : "query",
+ "hide" : 0,
+ "regex" : "",
+ "refresh" : 1,
+ "allValue" : null,
+ "sort" : 0
+ },
+ {
+ "current" : {
+ "text" : "test.lab",
+ "value" : "test.lab"
+ },
+ "name" : "domain",
+ "query" : "test.lab",
+ "options" : [
+ {
+ "selected" : true,
+ "text" : "test.lab",
+ "value" : "test.lab"
+ }
+ ],
+ "label" : null,
+ "type" : "custom",
+ "hide" : 2,
+ "allValue" : null,
+ "multi" : false,
+ "includeAll" : false
+ },
+ {
+ "label" : "Percentile",
+ "current" : {
+ "value" : "95",
+ "text" : "95",
+ "selected" : true
+ },
+ "name" : "percentile",
+ "options" : [
+ {
+ "selected" : false,
+ "text" : "80",
+ "value" : "80"
+ },
+ {
+ "selected" : false,
+ "text" : "85",
+ "value" : "85"
+ },
+ {
+ "selected" : false,
+ "text" : "90",
+ "value" : "90"
+ },
+ {
+ "selected" : true,
+ "value" : "95",
+ "text" : "95"
+ },
+ {
+ "selected" : false,
+ "value" : "98",
+ "text" : "98"
+ }
+ ],
+ "query" : "80,85,90,95,98",
+ "type" : "custom",
+ "hide" : 0,
+ "includeAll" : false,
+ "multi" : false,
+ "allValue" : null
+ },
+ {
+ "hide" : 2,
+ "allValue" : null,
+ "multi" : true,
+ "includeAll" : true,
+ "options" : [
+ {
+ "selected" : true,
+ "text" : "All",
+ "value" : "$__all"
+ },
+ {
+ "value" : "ceph-1",
+ "text" : "ceph-1",
+ "selected" : false
+ },
+ {
+ "text" : "ceph-2",
+ "value" : "ceph-2",
+ "selected" : false
+ },
+ {
+ "value" : "ceph-3",
+ "text" : "ceph-3",
+ "selected" : false
+ }
+ ],
+ "query" : "ceph-1,ceph-2,ceph-3",
+ "current" : {
+ "selected" : true,
+ "text" : "All",
+ "value" : "$__all"
+ },
+ "name" : "osd_servers",
+ "label" : null,
+ "type" : "custom"
+ },
+ {
+ "hide" : 2,
+ "multi" : true,
+ "includeAll" : false,
+ "allValue" : null,
+ "label" : null,
+ "options" : [
+ {
+ "selected" : true,
+ "value" : "obj-rgw-1",
+ "text" : "obj-rgw-1"
+ }
+ ],
+ "query" : "obj-rgw-1",
+ "name" : "rgw_servers",
+ "current" : {
+ "text" : "obj-rgw-1",
+ "value" : "obj-rgw-1"
+ },
+ "type" : "custom"
+ },
+ {
+ "tagsQuery" : "",
+ "datasource" : "Local",
+ "multi" : true,
+ "includeAll" : true,
+ "tagValuesQuery" : "",
+ "query" : "collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.mon_status.*",
+ "label" : null,
+ "tags" : [],
+ "regex" : "",
+ "hide" : 2,
+ "sort" : 0,
+ "allValue" : null,
+ "refresh" : 1,
+ "options" : [],
+ "name" : "mon_servers",
+ "current" : {
+ "text" : "All",
+ "value" : "$__all"
+ },
+ "type" : "query",
+ "useTags" : false
+ },
+ {
+ "hide" : 2,
+ "multi" : false,
+ "includeAll" : false,
+ "allValue" : null,
+ "label" : null,
+ "query" : "85",
+ "options" : [
+ {
+ "value" : "85",
+ "text" : "85",
+ "selected" : true
+ }
+ ],
+ "current" : {
+ "value" : "85",
+ "text" : "85"
+ },
+ "name" : "disk_full_threshold",
+ "type" : "custom"
+ },
+ {
+ "hide" : 2,
+ "allValue" : null,
+ "multi" : false,
+ "includeAll" : false,
+ "name" : "growth_window",
+ "current" : {
+ "value" : "7d",
+ "text" : "7d"
+ },
+ "options" : [
+ {
+ "text" : "7d",
+ "value" : "7d",
+ "selected" : true
+ }
+ ],
+ "query" : "7d",
+ "label" : null,
+ "type" : "custom"
+ }
+ ]
+ },
+ "links" : [
+ {
+ "includeVars" : true,
+ "asDropdown" : true,
+ "tags" : [
+ "overview"
+ ],
+ "icon" : "external link",
+ "type" : "dashboards",
+ "targetBlank" : true,
+ "keepTime" : true,
+ "title" : "Shortcuts"
+ }
+ ],
+ "time" : {
+ "from" : "now-1h",
+ "to" : "now"
+ },
+ "annotations" : {
+ "list" : []
+ },
+ "editable" : false,
+ "title" : "Ceph - At A Glance",
+ "timepicker" : {
+ "time_options" : [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ],
+ "refresh_intervals" : [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ]
+ },
+ "graphTooltip" : 0,
+ "id" : 12,
+ "timezone" : "browser",
+ "tags" : [
+ "overview"
+ ],
+ "style" : "dark"
+ }
+}
--- /dev/null
+{
+ "dashboard" : {
+ "version" : 18,
+ "templating" : {
+ "list" : [
+ {
+ "tagsQuery" : "",
+ "name" : "cluster_name",
+ "multi" : false,
+ "tags" : [],
+ "label" : null,
+ "sort" : 0,
+ "regex" : "",
+ "refresh" : 1,
+ "hide" : 2,
+ "query" : "collectd.*.$domain.cephmetrics.gauge.*",
+ "options" : [],
+ "tagValuesQuery" : "",
+ "current" : {
+ "text" : "ceph",
+ "value" : "ceph",
+ "selected" : true
+ },
+ "allValue" : null,
+ "type" : "query",
+ "datasource" : "Local",
+ "includeAll" : false,
+ "useTags" : false
+ },
+ {
+ "type" : "custom",
+ "includeAll" : false,
+ "label" : null,
+ "name" : "domain",
+ "options" : [
+ {
+ "value" : "test.lab",
+ "text" : "test.lab",
+ "selected" : true
+ }
+ ],
+ "current" : {
+ "text" : "test.lab",
+ "value" : "test.lab",
+ "selected" : true
+ },
+ "multi" : false,
+ "allValue" : null,
+ "hide" : 2,
+ "query" : "test.lab"
+ },
+ {
+ "label" : "Percentile",
+ "includeAll" : false,
+ "type" : "custom",
+ "hide" : 0,
+ "query" : "80,85,90,95,98",
+ "allValue" : null,
+ "multi" : false,
+ "current" : {
+ "text" : "95",
+ "value" : "95",
+ "selected" : true
+ },
+ "name" : "percentile",
+ "options" : [
+ {
+ "value" : "80",
+ "text" : "80",
+ "selected" : false
+ },
+ {
+ "value" : "85",
+ "text" : "85",
+ "selected" : false
+ },
+ {
+ "value" : "90",
+ "text" : "90",
+ "selected" : false
+ },
+ {
+ "value" : "95",
+ "text" : "95",
+ "selected" : true
+ },
+ {
+ "selected" : false,
+ "text" : "98",
+ "value" : "98"
+ }
+ ]
+ },
+ {
+ "label" : "OSD Hostname",
+ "includeAll" : true,
+ "type" : "custom",
+ "hide" : 0,
+ "query" : "ceph-1,ceph-2,ceph-3",
+ "allValue" : "",
+ "multi" : true,
+ "current" : {
+ "value" : "$__all",
+ "text" : "All",
+ "selected" : true
+ },
+ "name" : "osd_servers",
+ "options" : [
+ {
+ "selected" : true,
+ "value" : "$__all",
+ "text" : "All"
+ },
+ {
+ "value" : "ceph-1",
+ "text" : "ceph-1",
+ "selected" : false
+ },
+ {
+ "selected" : false,
+ "value" : "ceph-2",
+ "text" : "ceph-2"
+ },
+ {
+ "value" : "ceph-3",
+ "text" : "ceph-3",
+ "selected" : false
+ }
+ ]
+ },
+ {
+ "hide" : 2,
+ "query" : "85",
+ "options" : [
+ {
+ "text" : "85",
+ "value" : "85",
+ "selected" : true
+ }
+ ],
+ "name" : "disk_full_threshold",
+ "allValue" : null,
+ "multi" : false,
+ "current" : {
+ "text" : "85",
+ "value" : "85",
+ "selected" : true
+ },
+ "label" : null,
+ "type" : "custom",
+ "includeAll" : false
+ }
+ ]
+ },
+ "rows" : [
+ {
+ "collapse" : false,
+ "repeat" : null,
+ "repeatIteration" : null,
+ "panels" : [
+ {
+ "sort" : {
+ "col" : null,
+ "desc" : false
+ },
+ "id" : 56,
+ "minSpan" : 1,
+ "title" : "OSD's Down",
+ "links" : [],
+ "targets" : [
+ {
+ "hide" : false,
+ "textEditor" : true,
+ "target" : "currentBelow(groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_state.*.up,-2,\"maxSeries\"),0.5)",
+ "refId" : "B"
+ }
+ ],
+ "hideTimeOverride" : true,
+ "fontSize" : "100%",
+ "transform" : "timeseries_aggregations",
+ "columns" : [
+ {
+ "text" : "Current",
+ "value" : "current"
+ }
+ ],
+ "styles" : [
+ {
+ "colorMode" : null,
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "pattern" : "Metric",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "sanitize" : false,
+ "decimals" : 0,
+ "thresholds" : [
+ ""
+ ],
+ "unit" : "short",
+ "type" : "number",
+ "alias" : "OSD Id"
+ },
+ {
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "pattern" : "Current",
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "colorMode" : "cell",
+ "alias" : "Status",
+ "decimals" : 0,
+ "thresholds" : [
+ "0"
+ ],
+ "unit" : "short",
+ "type" : "hidden"
+ }
+ ],
+ "timeFrom" : "1m",
+ "type" : "table",
+ "pageSize" : 100,
+ "span" : 1,
+ "timeShift" : null,
+ "scroll" : true,
+ "showHeader" : true
+ },
+ {
+ "scroll" : true,
+ "showHeader" : true,
+ "fontSize" : "100%",
+ "span" : 2,
+ "type" : "table",
+ "title" : "Disks Near Full",
+ "links" : [],
+ "minSpan" : 2,
+ "pageSize" : null,
+ "targets" : [
+ {
+ "target" : "aliasByNode(currentAbove(transformNull(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.osd_percent_used),0),$disk_full_threshold),1,-2)",
+ "refId" : "A",
+ "textEditor" : true
+ }
+ ],
+ "id" : 57,
+ "styles" : [
+ {
+ "type" : "date",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "alias" : "Time",
+ "pattern" : "Time"
+ },
+ {
+ "colorMode" : null,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "pattern" : "Host and Disk",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "thresholds" : [],
+ "decimals" : 0,
+ "unit" : "short",
+ "type" : "number",
+ "alias" : "% Full"
+ },
+ {
+ "unit" : "none",
+ "type" : "number",
+ "decimals" : 0,
+ "thresholds" : [],
+ "alias" : "% Full",
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "colorMode" : null,
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "pattern" : "Current"
+ },
+ {
+ "unit" : "short",
+ "type" : "number",
+ "decimals" : 2,
+ "thresholds" : [],
+ "alias" : "Host.OSD Id",
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "colorMode" : null,
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "pattern" : "Metric"
+ },
+ {
+ "alias" : "",
+ "type" : "number",
+ "unit" : "short",
+ "thresholds" : [],
+ "decimals" : 2,
+ "pattern" : "/.*/",
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "colorMode" : null
+ }
+ ],
+ "columns" : [
+ {
+ "text" : "Current",
+ "value" : "current"
+ }
+ ],
+ "sort" : {
+ "col" : 0,
+ "desc" : true
+ },
+ "transform" : "timeseries_aggregations"
+ },
+ {
+ "maxDataPoints" : "1",
+ "fontSize" : "100%",
+ "targets" : [
+ {
+ "textEditor" : true,
+ "refId" : "A",
+ "target" : "groupByNode(keepLastValue(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.stat_bytes),1,\"sumSeries\")"
+ }
+ ],
+ "minSpan" : 3,
+ "title" : "Host OSD Raw Capacity",
+ "links" : [],
+ "id" : 58,
+ "sort" : {
+ "col" : 0,
+ "desc" : false
+ },
+ "showHeader" : true,
+ "scroll" : true,
+ "span" : 3,
+ "pageSize" : null,
+ "type" : "table",
+ "columns" : [
+ {
+ "text" : "Current",
+ "value" : "current"
+ }
+ ],
+ "styles" : [
+ {
+ "type" : "date",
+ "pattern" : "Time",
+ "alias" : "Time",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss"
+ },
+ {
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "colorMode" : null,
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "pattern" : "Current",
+ "decimals" : 2,
+ "thresholds" : [],
+ "unit" : "decbytes",
+ "type" : "number",
+ "alias" : "Total OSD Capacity"
+ },
+ {
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "pattern" : "Metric",
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "colorMode" : null,
+ "alias" : "Host Name",
+ "decimals" : 2,
+ "thresholds" : [],
+ "type" : "number",
+ "unit" : "short"
+ },
+ {
+ "type" : "number",
+ "unit" : "short",
+ "thresholds" : [],
+ "decimals" : 2,
+ "alias" : "",
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "colorMode" : null,
+ "pattern" : "/.*/"
+ }
+ ],
+ "transform" : "timeseries_aggregations"
+ },
+ {
+ "span" : 3,
+ "scroll" : true,
+ "showHeader" : true,
+ "transform" : "timeseries_aggregations",
+ "columns" : [
+ {
+ "value" : "current",
+ "text" : "Current"
+ }
+ ],
+ "styles" : [
+ {
+ "type" : "date",
+ "alias" : "Time",
+ "pattern" : "Time",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss"
+ },
+ {
+ "alias" : "# OSDs",
+ "thresholds" : [],
+ "decimals" : 0,
+ "unit" : "none",
+ "type" : "number",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "pattern" : "Current",
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "colorMode" : null
+ },
+ {
+ "pattern" : "Metric",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "colorMode" : null,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "alias" : "Host Name",
+ "unit" : "short",
+ "type" : "number",
+ "thresholds" : [],
+ "decimals" : 2
+ },
+ {
+ "unit" : "short",
+ "type" : "number",
+ "thresholds" : [],
+ "decimals" : 2,
+ "alias" : "",
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "colorMode" : null,
+ "pattern" : "/.*/"
+ }
+ ],
+ "type" : "table",
+ "pageSize" : null,
+ "fontSize" : "100%",
+ "maxDataPoints" : "10",
+ "sort" : {
+ "col" : 0,
+ "desc" : false
+ },
+ "id" : 59,
+ "title" : "Host OSD Capacity Breakdown",
+ "minSpan" : 3,
+ "links" : [],
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : "aliasByNode(keepLastValue(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.num_osds,6),1)",
+ "textEditor" : true
+ }
+ ]
+ }
+ ],
+ "height" : 250,
+ "title" : "Disk/OSD Host Summary",
+ "showTitle" : true,
+ "titleSize" : "h5",
+ "repeatRowId" : null
+ },
+ {
+ "collapse" : true,
+ "repeat" : null,
+ "repeatIteration" : null,
+ "panels" : [
+ {
+ "yAxis" : {
+ "format" : "short",
+ "decimals" : null,
+ "logBase" : 1,
+ "max" : "100",
+ "show" : true,
+ "splitFactor" : null,
+ "min" : "0"
+ },
+ "type" : "heatmap",
+ "yBucketSize" : 5,
+ "dataFormat" : "timeseries",
+ "color" : {
+ "cardColor" : "#b4ff00",
+ "mode" : "spectrum",
+ "exponent" : 0.5,
+ "colorScheme" : "interpolateRdYlGn",
+ "colorScale" : "sqrt"
+ },
+ "xBucketNumber" : 180,
+ "span" : 6,
+ "description" : "The heatmap categorizes disk utilization into discrete buckets (e.g util 0-5) and shows the frequency of the number of disks that fall within that range as a color. The color chosen depends on the number of disks in the 'bucket', ranging from green (low) to red (high). Hover over a colored block to show the count of disk utilization observations at that point.",
+ "id" : 53,
+ "highlightCards" : true,
+ "xAxis" : {
+ "show" : true
+ },
+ "yBucketNumber" : null,
+ "targets" : [
+ {
+ "textEditor" : true,
+ "target" : "collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.util",
+ "refId" : "A"
+ }
+ ],
+ "title" : "Disk Drive Utilization Heatmap - $osd_servers",
+ "links" : [],
+ "minSpan" : 6,
+ "tooltip" : {
+ "showHistogram" : false,
+ "show" : true
+ },
+ "xBucketSize" : "",
+ "heatmap" : {},
+ "cards" : {
+ "cardPadding" : null,
+ "cardRound" : null
+ }
+ },
+ {
+ "bars" : false,
+ "span" : 6,
+ "renderer" : "flot",
+ "pointradius" : 5,
+ "timeShift" : null,
+ "steppedLine" : false,
+ "stack" : true,
+ "percentage" : false,
+ "dashLength" : 10,
+ "timeFrom" : null,
+ "datasource" : "Local",
+ "type" : "graph",
+ "fill" : 1,
+ "legend" : {
+ "values" : false,
+ "current" : false,
+ "avg" : false,
+ "total" : false,
+ "show" : true,
+ "max" : false,
+ "min" : false
+ },
+ "xaxis" : {
+ "buckets" : null,
+ "values" : [],
+ "name" : null,
+ "mode" : "time",
+ "show" : true
+ },
+ "spaceLength" : 10,
+ "nullPointMode" : "null",
+ "linewidth" : 1,
+ "yaxes" : [
+ {
+ "logBase" : 1,
+ "format" : "decbytes",
+ "label" : null,
+ "show" : true,
+ "max" : null,
+ "min" : "0"
+ },
+ {
+ "max" : null,
+ "label" : null,
+ "show" : true,
+ "min" : null,
+ "format" : "short",
+ "logBase" : 1
+ }
+ ],
+ "tooltip" : {
+ "value_type" : "individual",
+ "shared" : true,
+ "sort" : 0
+ },
+ "lines" : true,
+ "dashes" : false,
+ "seriesOverrides" : [],
+ "aliasColors" : {
+ "Read Throughput" : "#629E51",
+ "Write Throughput" : "#E0752D"
+ },
+ "points" : false,
+ "id" : 24,
+ "thresholds" : [],
+ "targets" : [
+ {
+ "textEditor" : true,
+ "target" : "alias(sumSeries(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.r_bytes_per_sec), \"Read Throughput\")",
+ "refId" : "A"
+ },
+ {
+ "refId" : "B",
+ "target" : "alias(sumSeries(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.w_bytes_per_sec), \"Write Throughput\")",
+ "textEditor" : true
+ }
+ ],
+ "title" : "Disk Throughput - $osd_servers",
+ "links" : [],
+ "minSpan" : 6
+ },
+ {
+ "bars" : false,
+ "pointradius" : 5,
+ "renderer" : "flot",
+ "span" : 6,
+ "timeShift" : null,
+ "steppedLine" : false,
+ "stack" : true,
+ "dashLength" : 10,
+ "percentage" : false,
+ "timeFrom" : null,
+ "type" : "graph",
+ "datasource" : "Local",
+ "xaxis" : {
+ "values" : [],
+ "name" : null,
+ "buckets" : null,
+ "mode" : "time",
+ "show" : true
+ },
+ "spaceLength" : 10,
+ "nullPointMode" : "null as zero",
+ "legend" : {
+ "show" : true,
+ "max" : false,
+ "min" : false,
+ "values" : false,
+ "avg" : false,
+ "current" : false,
+ "total" : false
+ },
+ "fill" : 1,
+ "yaxes" : [
+ {
+ "min" : "0",
+ "max" : null,
+ "show" : true,
+ "label" : null,
+ "format" : "ms",
+ "logBase" : 1
+ },
+ {
+ "format" : "short",
+ "logBase" : 1,
+ "max" : null,
+ "show" : true,
+ "label" : null,
+ "min" : null
+ }
+ ],
+ "linewidth" : 1,
+ "dashes" : false,
+ "lines" : true,
+ "tooltip" : {
+ "sort" : 0,
+ "shared" : true,
+ "value_type" : "individual"
+ },
+ "aliasColors" : {
+ "Read Latency" : "#629E51",
+ "Write Latency" : "#E0752D"
+ },
+ "seriesOverrides" : [],
+ "points" : false,
+ "id" : 40,
+ "title" : "Disk Latency - $osd_servers OSDs @ $percentile%ile",
+ "minSpan" : 6,
+ "links" : [
+ {
+ "dashboard" : "Latency by Server",
+ "keepTime" : true,
+ "targetBlank" : true,
+ "dashUri" : "db/latency-by-server",
+ "includeVars" : true,
+ "type" : "dashboard",
+ "title" : "Latency by Server"
+ }
+ ],
+ "targets" : [
+ {
+ "textEditor" : true,
+ "refId" : "A",
+ "target" : "alias(percentileOfSeries(group(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.r_await),$percentile), \"Read Latency\")"
+ },
+ {
+ "textEditor" : true,
+ "target" : "alias(percentileOfSeries(group(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.w_await),$percentile), \"Write Latency\")",
+ "refId" : "C"
+ }
+ ],
+ "thresholds" : [
+ {
+ "op" : "gt",
+ "colorMode" : "custom",
+ "lineColor" : "rgba(178, 0, 0, 0.29)",
+ "fill" : false,
+ "line" : true,
+ "value" : 50
+ }
+ ]
+ },
+ {
+ "fill" : 1,
+ "spaceLength" : 10,
+ "xaxis" : {
+ "name" : null,
+ "values" : [],
+ "buckets" : null,
+ "mode" : "time",
+ "show" : true
+ },
+ "nullPointMode" : "null",
+ "legend" : {
+ "show" : true,
+ "max" : false,
+ "min" : false,
+ "values" : true,
+ "current" : true,
+ "avg" : false,
+ "total" : false
+ },
+ "tooltip" : {
+ "sort" : 0,
+ "shared" : true,
+ "value_type" : "individual"
+ },
+ "lines" : true,
+ "dashes" : false,
+ "linewidth" : 1,
+ "yaxes" : [
+ {
+ "logBase" : 1,
+ "format" : "short",
+ "label" : "",
+ "show" : true,
+ "max" : "100",
+ "min" : "0"
+ },
+ {
+ "format" : "short",
+ "logBase" : 1,
+ "max" : null,
+ "show" : false,
+ "label" : null,
+ "min" : null
+ }
+ ],
+ "seriesOverrides" : [],
+ "aliasColors" : {
+ "disk busy %" : "#3F6833"
+ },
+ "thresholds" : [
+ {
+ "colorMode" : "custom",
+ "op" : "gt",
+ "value" : 80,
+ "fill" : false,
+ "line" : true,
+ "lineColor" : "rgba(178, 0, 0, 0.29)"
+ }
+ ],
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : "alias(percentileOfSeries(group(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.util),$percentile), \"disk busy %\")",
+ "textEditor" : true
+ }
+ ],
+ "minSpan" : 6,
+ "title" : "Disk Utilization - $osd_servers OSDs at $percentile%ile",
+ "links" : [
+ {
+ "dashUri" : "db/disk-busy-by-server",
+ "targetBlank" : true,
+ "keepTime" : true,
+ "dashboard" : "Disk Busy by Server",
+ "type" : "dashboard",
+ "title" : "Disk Busy by Server",
+ "includeVars" : true
+ }
+ ],
+ "id" : 43,
+ "points" : false,
+ "span" : 6,
+ "renderer" : "flot",
+ "pointradius" : 5,
+ "bars" : false,
+ "steppedLine" : false,
+ "timeShift" : null,
+ "percentage" : false,
+ "dashLength" : 10,
+ "stack" : false,
+ "datasource" : "Local",
+ "type" : "graph",
+ "timeFrom" : null
+ },
+ {
+ "timeShift" : null,
+ "steppedLine" : false,
+ "bars" : false,
+ "pointradius" : 5,
+ "renderer" : "flot",
+ "span" : 6,
+ "timeFrom" : null,
+ "type" : "graph",
+ "datasource" : "Local",
+ "stack" : false,
+ "dashLength" : 10,
+ "percentage" : false,
+ "yaxes" : [
+ {
+ "format" : "short",
+ "logBase" : 1,
+ "max" : null,
+ "show" : true,
+ "label" : null,
+ "min" : "0"
+ },
+ {
+ "format" : "short",
+ "logBase" : 1,
+ "max" : null,
+ "show" : true,
+ "label" : null,
+ "min" : null
+ }
+ ],
+ "linewidth" : 1,
+ "lines" : true,
+ "dashes" : false,
+ "tooltip" : {
+ "value_type" : "individual",
+ "shared" : true,
+ "sort" : 0
+ },
+ "spaceLength" : 10,
+ "xaxis" : {
+ "mode" : "time",
+ "show" : true,
+ "name" : null,
+ "values" : [],
+ "buckets" : null
+ },
+ "legend" : {
+ "values" : false,
+ "total" : false,
+ "avg" : false,
+ "current" : false,
+ "max" : false,
+ "show" : false,
+ "min" : false
+ },
+ "nullPointMode" : "null",
+ "fill" : 1,
+ "id" : 46,
+ "points" : false,
+ "title" : "IOPS per Disk @ $percentile%ile - $osd_servers OSDs",
+ "minSpan" : 6,
+ "links" : [],
+ "thresholds" : [],
+ "targets" : [
+ {
+ "textEditor" : true,
+ "target" : "alias(percentileOfSeries(group(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.iops),$percentile),\"IOPS/spindle\")",
+ "refId" : "A"
+ }
+ ],
+ "aliasColors" : {
+ "IOPS/spindle" : "#3F6833"
+ },
+ "seriesOverrides" : []
+ },
+ {
+ "xaxis" : {
+ "values" : [],
+ "buckets" : null,
+ "name" : null,
+ "mode" : "time",
+ "show" : true
+ },
+ "spaceLength" : 10,
+ "legend" : {
+ "values" : false,
+ "total" : false,
+ "current" : false,
+ "avg" : false,
+ "max" : false,
+ "show" : false,
+ "min" : false
+ },
+ "nullPointMode" : "null",
+ "fill" : 1,
+ "dashes" : false,
+ "lines" : true,
+ "tooltip" : {
+ "shared" : true,
+ "sort" : 0,
+ "value_type" : "individual"
+ },
+ "yaxes" : [
+ {
+ "min" : "0",
+ "max" : null,
+ "label" : null,
+ "show" : true,
+ "format" : "short",
+ "logBase" : 1
+ },
+ {
+ "min" : null,
+ "label" : null,
+ "show" : false,
+ "max" : null,
+ "logBase" : 1,
+ "format" : "short"
+ }
+ ],
+ "linewidth" : 1,
+ "aliasColors" : {
+ "IOPS" : "#3F6833"
+ },
+ "seriesOverrides" : [],
+ "title" : "Total Disk IOPS - $osd_servers OSDs",
+ "links" : [
+ {
+ "targetBlank" : true,
+ "keepTime" : true,
+ "dashboard" : "IOPS by Server",
+ "dashUri" : "db/iops-by-server",
+ "includeVars" : true,
+ "type" : "dashboard",
+ "title" : "IOPS by Server"
+ }
+ ],
+ "minSpan" : 6,
+ "thresholds" : [],
+ "targets" : [
+ {
+ "textEditor" : true,
+ "target" : "alias(sumSeries(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.iops),\"IOPS\")",
+ "refId" : "A"
+ }
+ ],
+ "points" : false,
+ "id" : 47,
+ "pointradius" : 5,
+ "renderer" : "flot",
+ "span" : 6,
+ "bars" : false,
+ "steppedLine" : false,
+ "timeShift" : null,
+ "dashLength" : 10,
+ "percentage" : false,
+ "stack" : false,
+ "datasource" : "Local",
+ "type" : "graph",
+ "timeFrom" : null
+ }
+ ],
+ "height" : "300",
+ "title" : "Disk/OSD Load Summary",
+ "showTitle" : true,
+ "titleSize" : "h5",
+ "repeatRowId" : null
+ },
+ {
+ "repeat" : null,
+ "repeatIteration" : null,
+ "collapse" : true,
+ "showTitle" : true,
+ "titleSize" : "h5",
+ "repeatRowId" : null,
+ "panels" : [
+ {
+ "points" : false,
+ "id" : 44,
+ "minSpan" : 6,
+ "title" : "CPU Utilization - $osd_servers",
+ "links" : [],
+ "thresholds" : [],
+ "targets" : [
+ {
+ "textEditor" : true,
+ "target" : "alias(percentileOfSeries(groupByNode(collectd.*.$domain.cpu.percent.{wait,interrupt,nice,user,system}, 1, \"sumSeries\"),$percentile),\"Cluster-wide CPU Busy @ $percentile%ile\")",
+ "refId" : "A"
+ },
+ {
+ "textEditor" : true,
+ "hide" : false,
+ "target" : "alias(averageSeries(groupByNode(collectd.$osd_servers.$domain.cpu.percent.{wait,interrupt,nice,user,system}, 1, \"sumSeries\")),\"Average OSD Host(s) CPU Busy\")",
+ "refId" : "B"
+ }
+ ],
+ "aliasColors" : {
+ "CPU Busy" : "#447EBC",
+ "CPU Busy @ 95%ile" : "#890F02",
+ "Cluster-wide CPU Busy @ 95%ile" : "#890F02",
+ "Max CPU Busy" : "#BF1B00",
+ "Max CPU Busy - all OSD Hosts" : "#BF1B00"
+ },
+ "seriesOverrides" : [
+ {
+ "alias" : "Cluster-wide CPU Busy @ 95%ile",
+ "fill" : 0
+ }
+ ],
+ "yaxes" : [
+ {
+ "max" : "100",
+ "label" : "",
+ "show" : true,
+ "min" : "0",
+ "format" : "short",
+ "logBase" : 1
+ },
+ {
+ "label" : null,
+ "show" : true,
+ "max" : null,
+ "min" : null,
+ "logBase" : 1,
+ "format" : "short"
+ }
+ ],
+ "linewidth" : 1,
+ "lines" : true,
+ "dashes" : false,
+ "tooltip" : {
+ "value_type" : "individual",
+ "sort" : 0,
+ "shared" : true
+ },
+ "xaxis" : {
+ "show" : true,
+ "mode" : "time",
+ "values" : [],
+ "name" : null,
+ "buckets" : null
+ },
+ "nullPointMode" : "null as zero",
+ "spaceLength" : 10,
+ "legend" : {
+ "total" : false,
+ "avg" : false,
+ "current" : false,
+ "values" : false,
+ "min" : false,
+ "max" : false,
+ "show" : true
+ },
+ "fill" : 3,
+ "timeFrom" : null,
+ "datasource" : "Local",
+ "type" : "graph",
+ "stack" : false,
+ "dashLength" : 10,
+ "percentage" : false,
+ "timeShift" : null,
+ "steppedLine" : false,
+ "bars" : false,
+ "renderer" : "flot",
+ "pointradius" : 5,
+ "span" : 6
+ },
+ {
+ "aliasColors" : {
+ "Network load (rx+tx)" : "#3F6833"
+ },
+ "seriesOverrides" : [],
+ "thresholds" : [],
+ "targets" : [
+ {
+ "target" : "collectd.$osd_servers.$domain.interface.*.if_octets.rx",
+ "refId" : "A",
+ "hide" : true
+ },
+ {
+ "target" : "collectd.$osd_servers.$domain.interface.*.if_octets.tx",
+ "refId" : "B",
+ "hide" : true
+ },
+ {
+ "textEditor" : true,
+ "target" : "alias(sumSeries(#A,#B), \"Network load (rx+tx)\")",
+ "targetFull" : "alias(sumSeries(collectd.$osd_servers.$domain.interface.*.if_octets.rx,collectd.$osd_servers.$domain.interface.*.if_octets.tx), \"Network load (rx+tx)\")",
+ "refId" : "C"
+ }
+ ],
+ "minSpan" : 6,
+ "title" : "Network Load - $osd_servers",
+ "links" : [
+ {
+ "dashboard" : "Network Usage by Node",
+ "keepTime" : true,
+ "targetBlank" : true,
+ "dashUri" : "db/network-usage-by-node",
+ "includeVars" : true,
+ "title" : "Network Load by Node",
+ "type" : "dashboard"
+ }
+ ],
+ "id" : 49,
+ "points" : false,
+ "fill" : 1,
+ "xaxis" : {
+ "values" : [],
+ "name" : null,
+ "buckets" : null,
+ "mode" : "time",
+ "show" : true
+ },
+ "spaceLength" : 10,
+ "legend" : {
+ "values" : false,
+ "total" : false,
+ "avg" : false,
+ "current" : false,
+ "max" : false,
+ "show" : true,
+ "min" : false
+ },
+ "nullPointMode" : "null",
+ "tooltip" : {
+ "value_type" : "individual",
+ "sort" : 0,
+ "shared" : true
+ },
+ "dashes" : false,
+ "lines" : true,
+ "linewidth" : 1,
+ "yaxes" : [
+ {
+ "logBase" : 1,
+ "format" : "bytes",
+ "min" : null,
+ "label" : null,
+ "show" : true,
+ "max" : null
+ },
+ {
+ "format" : "short",
+ "logBase" : 1,
+ "max" : null,
+ "show" : true,
+ "label" : null,
+ "min" : null
+ }
+ ],
+ "percentage" : false,
+ "dashLength" : 10,
+ "stack" : false,
+ "datasource" : "Local",
+ "type" : "graph",
+ "timeFrom" : null,
+ "span" : 6,
+ "renderer" : "flot",
+ "pointradius" : 5,
+ "bars" : false,
+ "steppedLine" : false,
+ "timeShift" : null
+ }
+ ],
+ "height" : 250,
+ "title" : "OSD Host CPU and Network Load"
+ }
+ ],
+ "title" : "Ceph Backend Storage",
+ "links" : [
+ {
+ "includeVars" : true,
+ "tags" : [
+ "overview"
+ ],
+ "icon" : "external link",
+ "title" : "Shortcuts",
+ "type" : "dashboards",
+ "keepTime" : true,
+ "targetBlank" : true,
+ "asDropdown" : true
+ }
+ ],
+ "id" : 13,
+ "style" : "dark",
+ "tags" : [],
+ "timepicker" : {
+ "time_options" : [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ],
+ "refresh_intervals" : [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ]
+ },
+ "hideControls" : true,
+ "annotations" : {
+ "list" : []
+ },
+ "timezone" : "browser",
+ "graphTooltip" : 0,
+ "schemaVersion" : 14,
+ "time" : {
+ "from" : "now-1h",
+ "to" : "now"
+ },
+ "refresh" : "10s",
+ "gnetId" : null,
+ "editable" : false
+ },
+ "meta" : {
+ "slug" : "ceph-backend-storage",
+ "expires" : "0001-01-01T00:00:00Z",
+ "canStar" : true,
+ "createdBy" : "admin",
+ "canEdit" : true,
+ "updated" : "2017-08-18T21:45:43Z",
+ "version" : 18,
+ "canSave" : true,
+ "created" : "2017-08-03T21:42:28Z",
+ "updatedBy" : "admin",
+ "type" : "db"
+ }
+}
--- /dev/null
+{
+ "dashboard" : {
+ "rows" : [
+ {
+ "repeatIteration" : null,
+ "title" : "Cluster Configuration",
+ "height" : "100",
+ "repeat" : null,
+ "showTitle" : true,
+ "collapse" : false,
+ "panels" : [
+ {
+ "content" : "",
+ "title" : "",
+ "minSpan" : 1,
+ "span" : 1,
+ "links" : [],
+ "type" : "text",
+ "id" : 74,
+ "transparent" : true,
+ "mode" : "markdown"
+ },
+ {
+ "id" : 73,
+ "tableColumn" : "",
+ "mappingType" : 1,
+ "colorBackground" : false,
+ "format" : "none",
+ "decimals" : 0,
+ "sparkline" : {
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : false
+ },
+ "title" : "MONs",
+ "cacheTimeout" : null,
+ "maxDataPoints" : 100,
+ "nullPointMode" : "connected",
+ "type" : "singlestat",
+ "postfixFontSize" : "50%",
+ "prefix" : "",
+ "valueFontSize" : "80%",
+ "colorValue" : false,
+ "links" : [],
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "value" : 2,
+ "name" : "range to text"
+ }
+ ],
+ "valueMaps" : [
+ {
+ "text" : "N/A",
+ "value" : "null",
+ "op" : "="
+ }
+ ],
+ "span" : 1,
+ "rangeMaps" : [
+ {
+ "to" : "null",
+ "from" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "targets" : [
+ {
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pool",
+ "target" : "alias(keepLastValue(consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_mon), \"max\")),\"mons\")",
+ "groupBy" : [],
+ "dsType" : "influxdb",
+ "resultFormat" : "time_series",
+ "textEditor" : true,
+ "tags" : [],
+ "policy" : "default",
+ "refId" : "A",
+ "select" : [
+ [
+ {
+ "params" : [
+ "value"
+ ],
+ "type" : "field"
+ }
+ ]
+ ]
+ }
+ ],
+ "postfix" : "",
+ "datasource" : "Local",
+ "valueName" : "current",
+ "nullText" : null,
+ "gauge" : {
+ "show" : false,
+ "maxValue" : 100,
+ "minValue" : 0,
+ "thresholdMarkers" : true,
+ "thresholdLabels" : false
+ },
+ "interval" : null,
+ "thresholds" : "",
+ "prefixFontSize" : "50%",
+ "minSpan" : 1
+ },
+ {
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "value" : 2,
+ "name" : "range to text"
+ }
+ ],
+ "links" : [],
+ "colorValue" : false,
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "value" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "span" : 1,
+ "valueFontSize" : "80%",
+ "prefix" : "",
+ "title" : "OSD Hosts",
+ "sparkline" : {
+ "show" : false,
+ "lineColor" : "rgb(31, 120, 193)",
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false
+ },
+ "nullPointMode" : "connected",
+ "maxDataPoints" : "",
+ "cacheTimeout" : null,
+ "type" : "singlestat",
+ "postfixFontSize" : "50%",
+ "tableColumn" : "",
+ "id" : 68,
+ "mappingType" : 1,
+ "colorBackground" : false,
+ "format" : "none",
+ "decimals" : 0,
+ "interval" : null,
+ "minSpan" : 1,
+ "thresholds" : "",
+ "prefixFontSize" : "50%",
+ "nullText" : null,
+ "gauge" : {
+ "show" : false,
+ "minValue" : 0,
+ "maxValue" : 100,
+ "thresholdLabels" : false,
+ "thresholdMarkers" : true
+ },
+ "postfix" : "",
+ "datasource" : "Local",
+ "valueName" : "current",
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "rangeMaps" : [
+ {
+ "to" : "null",
+ "from" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "targets" : [
+ {
+ "textEditor" : true,
+ "target" : "maxSeries(consolidateBy(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd_hosts, \"max\"))",
+ "refId" : "A"
+ }
+ ]
+ },
+ {
+ "colorBackground" : false,
+ "decimals" : 0,
+ "format" : "none",
+ "tableColumn" : "",
+ "id" : 72,
+ "mappingType" : 1,
+ "type" : "singlestat",
+ "postfixFontSize" : "50%",
+ "sparkline" : {
+ "show" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "lineColor" : "rgb(31, 120, 193)"
+ },
+ "title" : "MDS",
+ "cacheTimeout" : null,
+ "maxDataPoints" : 100,
+ "nullPointMode" : "connected",
+ "prefix" : "",
+ "valueFontSize" : "80%",
+ "colorValue" : false,
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "links" : [],
+ "span" : 1,
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "text" : "N/A",
+ "value" : "null"
+ }
+ ],
+ "targets" : [
+ {
+ "select" : [
+ [
+ {
+ "type" : "field",
+ "params" : [
+ "value"
+ ]
+ }
+ ]
+ ],
+ "refId" : "A",
+ "policy" : "default",
+ "tags" : [],
+ "textEditor" : true,
+ "groupBy" : [],
+ "target" : "alias(keepLastValue(consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_mds_up), \"max\")),\"mds\")",
+ "dsType" : "influxdb",
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pool",
+ "resultFormat" : "time_series"
+ }
+ ],
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "to" : "null",
+ "from" : "null"
+ }
+ ],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource" : "Local",
+ "valueName" : "current",
+ "postfix" : "",
+ "gauge" : {
+ "show" : false,
+ "maxValue" : 100,
+ "minValue" : 0,
+ "thresholdMarkers" : true,
+ "thresholdLabels" : false
+ },
+ "nullText" : null,
+ "interval" : null,
+ "thresholds" : "",
+ "prefixFontSize" : "50%",
+ "minSpan" : 1
+ },
+ {
+ "minSpan" : 1,
+ "prefixFontSize" : "50%",
+ "thresholds" : "",
+ "interval" : null,
+ "nullText" : null,
+ "gauge" : {
+ "thresholdLabels" : false,
+ "thresholdMarkers" : true,
+ "show" : false,
+ "maxValue" : 100,
+ "minValue" : 0
+ },
+ "postfix" : "",
+ "valueName" : "current",
+ "datasource" : "Local",
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "to" : "null",
+ "from" : "null"
+ }
+ ],
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : "countSeries(collectd.*.$domain.cephmetrics.derive.$cluster_name.rgw.put)",
+ "textEditor" : true
+ }
+ ],
+ "span" : 1,
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "text" : "0",
+ "value" : "null"
+ }
+ ],
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "links" : [],
+ "colorValue" : false,
+ "valueFontSize" : "80%",
+ "prefix" : "",
+ "nullPointMode" : "connected",
+ "maxDataPoints" : "",
+ "cacheTimeout" : null,
+ "title" : "RGW Hosts",
+ "sparkline" : {
+ "show" : false,
+ "lineColor" : "rgb(31, 120, 193)",
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)"
+ },
+ "postfixFontSize" : "50%",
+ "type" : "singlestat",
+ "mappingType" : 1,
+ "tableColumn" : "",
+ "id" : 69,
+ "format" : "none",
+ "decimals" : 0,
+ "colorBackground" : false
+ },
+ {
+ "gauge" : {
+ "thresholdLabels" : false,
+ "thresholdMarkers" : true,
+ "show" : false,
+ "minValue" : 0,
+ "maxValue" : 100
+ },
+ "nullText" : null,
+ "interval" : null,
+ "minSpan" : 1,
+ "thresholds" : "",
+ "prefixFontSize" : "50%",
+ "targets" : [
+ {
+ "target" : "countSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.iscsi.gw_name.*)",
+ "refId" : "A",
+ "textEditor" : true
+ }
+ ],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "rangeMaps" : [
+ {
+ "from" : "null",
+ "to" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "datasource" : "Local",
+ "valueName" : "current",
+ "postfix" : "",
+ "valueFontSize" : "80%",
+ "prefix" : "",
+ "links" : [],
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "colorValue" : false,
+ "span" : 1,
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "text" : "0",
+ "value" : "null"
+ }
+ ],
+ "colorBackground" : false,
+ "format" : "none",
+ "decimals" : 0,
+ "tableColumn" : "",
+ "id" : 71,
+ "mappingType" : 1,
+ "type" : "singlestat",
+ "postfixFontSize" : "50%",
+ "sparkline" : {
+ "show" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "lineColor" : "rgb(31, 120, 193)"
+ },
+ "title" : "iSCSI Hosts",
+ "maxDataPoints" : "",
+ "nullPointMode" : "connected",
+ "cacheTimeout" : null
+ },
+ {
+ "postfix" : "",
+ "valueName" : "current",
+ "datasource" : "Local",
+ "rangeMaps" : [
+ {
+ "to" : "null",
+ "from" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "targets" : [
+ {
+ "policy" : "default",
+ "refId" : "A",
+ "tags" : [],
+ "select" : [
+ [
+ {
+ "type" : "field",
+ "params" : [
+ "value"
+ ]
+ }
+ ]
+ ],
+ "dsType" : "influxdb",
+ "target" : "alias(keepLastValue(consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd), \"max\")),\"total\")",
+ "groupBy" : [],
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pool",
+ "resultFormat" : "time_series",
+ "textEditor" : true
+ }
+ ],
+ "thresholds" : "",
+ "prefixFontSize" : "50%",
+ "minSpan" : 2,
+ "interval" : null,
+ "nullText" : null,
+ "gauge" : {
+ "show" : false,
+ "maxValue" : 100,
+ "minValue" : 0,
+ "thresholdLabels" : false,
+ "thresholdMarkers" : true
+ },
+ "cacheTimeout" : null,
+ "maxDataPoints" : 100,
+ "nullPointMode" : "connected",
+ "title" : "OSDs",
+ "sparkline" : {
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : false
+ },
+ "postfixFontSize" : "50%",
+ "type" : "singlestat",
+ "mappingType" : 1,
+ "tableColumn" : "",
+ "id" : 67,
+ "decimals" : 0,
+ "format" : "none",
+ "colorBackground" : false,
+ "span" : 2,
+ "valueMaps" : [
+ {
+ "value" : "null",
+ "text" : "N/A",
+ "op" : "="
+ }
+ ],
+ "colorValue" : false,
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "value" : 2,
+ "name" : "range to text"
+ }
+ ],
+ "links" : [],
+ "prefix" : "",
+ "valueFontSize" : "80%"
+ },
+ {
+ "tableColumn" : "",
+ "id" : 17,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "mappingType" : 1,
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "to" : "null",
+ "from" : "null"
+ }
+ ],
+ "colorBackground" : false,
+ "format" : "none",
+ "targets" : [
+ {
+ "refId" : "A",
+ "policy" : "default",
+ "tags" : [],
+ "select" : [
+ [
+ {
+ "params" : [
+ "value"
+ ],
+ "type" : "field"
+ }
+ ]
+ ],
+ "resultFormat" : "time_series",
+ "groupBy" : [],
+ "target" : "maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_pool)",
+ "dsType" : "influxdb",
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pool",
+ "textEditor" : true
+ }
+ ],
+ "sparkline" : {
+ "show" : false,
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "lineColor" : "rgb(31, 120, 193)"
+ },
+ "title" : "Pools",
+ "postfix" : "",
+ "nullPointMode" : "connected",
+ "maxDataPoints" : 100,
+ "cacheTimeout" : null,
+ "datasource" : "Local",
+ "type" : "singlestat",
+ "postfixFontSize" : "50%",
+ "valueName" : "current",
+ "nullText" : null,
+ "valueFontSize" : "80%",
+ "prefix" : "",
+ "gauge" : {
+ "show" : false,
+ "maxValue" : 100,
+ "minValue" : 0,
+ "thresholdLabels" : false,
+ "thresholdMarkers" : true
+ },
+ "links" : [],
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "value" : 2,
+ "name" : "range to text"
+ }
+ ],
+ "interval" : null,
+ "colorValue" : false,
+ "minSpan" : 1,
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "value" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "span" : 1,
+ "thresholds" : "",
+ "prefixFontSize" : "50%"
+ },
+ {
+ "prefix" : "",
+ "valueFontSize" : "80%",
+ "colorValue" : false,
+ "links" : [],
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "valueMaps" : [
+ {
+ "value" : "null",
+ "text" : "N/A",
+ "op" : "="
+ }
+ ],
+ "span" : 2,
+ "id" : 70,
+ "tableColumn" : "",
+ "mappingType" : 1,
+ "colorBackground" : false,
+ "format" : "decbytes",
+ "decimals" : 1,
+ "sparkline" : {
+ "lineColor" : "rgb(31, 120, 193)",
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "show" : false
+ },
+ "title" : "Unused Capacity",
+ "cacheTimeout" : null,
+ "nullPointMode" : "connected",
+ "maxDataPoints" : 100,
+ "type" : "singlestat",
+ "postfixFontSize" : "50%",
+ "nullText" : null,
+ "gauge" : {
+ "maxValue" : 100,
+ "minValue" : 0,
+ "show" : false,
+ "thresholdMarkers" : true,
+ "thresholdLabels" : false
+ },
+ "interval" : null,
+ "thresholds" : "",
+ "prefixFontSize" : "50%",
+ "minSpan" : 2,
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "to" : "null",
+ "from" : "null"
+ }
+ ],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "targets" : [
+ {
+ "textEditor" : true,
+ "target" : "alias(keepLastValue(consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_avail), \"max\")),\"freespacel\")",
+ "refId" : "A"
+ }
+ ],
+ "postfix" : "",
+ "datasource" : null,
+ "valueName" : "current"
+ }
+ ],
+ "titleSize" : "h5",
+ "repeatRowId" : null
+ },
+ {
+ "repeatIteration" : null,
+ "title" : "Cluster Flags",
+ "collapse" : false,
+ "showTitle" : false,
+ "repeat" : null,
+ "height" : "100",
+ "repeatRowId" : null,
+ "panels" : [
+ {
+ "id" : 66,
+ "transparent" : true,
+ "mode" : "markdown",
+ "content" : "",
+ "title" : "",
+ "minSpan" : 2,
+ "span" : 2,
+ "type" : "text",
+ "links" : []
+ },
+ {
+ "type" : "text",
+ "links" : [],
+ "minSpan" : 1,
+ "span" : 1,
+ "title" : "",
+ "content" : "<h2 style=\"text-align: center;\">Cluster Flags:</h2>",
+ "height" : "95",
+ "mode" : "html",
+ "transparent" : true,
+ "id" : 58
+ },
+ {
+ "gauge" : {
+ "maxValue" : 100,
+ "minValue" : 0,
+ "show" : false,
+ "thresholdLabels" : false,
+ "thresholdMarkers" : true
+ },
+ "nullText" : null,
+ "prefixFontSize" : "50%",
+ "thresholds" : "1,2",
+ "minSpan" : 1,
+ "interval" : null,
+ "timeShift" : null,
+ "targets" : [
+ {
+ "textEditor" : true,
+ "refId" : "A",
+ "target" : "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.scrub),\"maxSeries\"))"
+ }
+ ],
+ "rangeMaps" : [
+ {
+ "from" : "null",
+ "to" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "valueName" : "current",
+ "datasource" : "Local",
+ "timeFrom" : "1m",
+ "postfix" : "",
+ "height" : "95",
+ "prefix" : "",
+ "valueFontSize" : "40%",
+ "description" : "Scrub activity takes place daily basis across the OSD's and performs object size and attribute checks. Scrub activity can be controlled with the \"ceph osd scrub\" command.",
+ "valueMaps" : [
+ {
+ "text" : "N/A",
+ "value" : "null",
+ "op" : "="
+ },
+ {
+ "value" : "0",
+ "text" : "ENABLED",
+ "op" : "="
+ },
+ {
+ "value" : "1",
+ "text" : "ACTIVE",
+ "op" : "="
+ },
+ {
+ "text" : "DISABLED",
+ "value" : "2",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "value" : "-1",
+ "text" : "NODATA"
+ }
+ ],
+ "span" : 1,
+ "colorValue" : false,
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "links" : [],
+ "format" : "none",
+ "colorBackground" : true,
+ "mappingType" : 1,
+ "hideTimeOverride" : true,
+ "tableColumn" : "",
+ "id" : 57,
+ "postfixFontSize" : "50%",
+ "type" : "singlestat",
+ "cacheTimeout" : null,
+ "nullPointMode" : "connected",
+ "maxDataPoints" : "",
+ "sparkline" : {
+ "lineColor" : "rgb(31, 120, 193)",
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "show" : false
+ },
+ "title" : "SCRUB"
+ },
+ {
+ "colorValue" : false,
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "links" : [],
+ "valueMaps" : [
+ {
+ "text" : "N/A",
+ "value" : "null",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "value" : "0",
+ "text" : "ENABLED"
+ },
+ {
+ "op" : "=",
+ "text" : "ACTIVE",
+ "value" : "1"
+ },
+ {
+ "op" : "=",
+ "text" : "DISABLED",
+ "value" : "2"
+ },
+ {
+ "value" : "-1",
+ "text" : "NODATA",
+ "op" : "="
+ }
+ ],
+ "span" : 1,
+ "height" : "95",
+ "description" : "Deep scrub acts on the objects within placement groups (PGs). Objects are read, and checksum's compared to protect against silent bit-rot events. Although a weekly activity, in large clusters is normal to see deep-scrub active on a daily basis. Scrub activity can be controlled with the \"ceph osd scrub\" command.",
+ "prefix" : "",
+ "valueFontSize" : "40%",
+ "type" : "singlestat",
+ "postfixFontSize" : "50%",
+ "title" : "DEEP SCRUB",
+ "sparkline" : {
+ "lineColor" : "rgb(31, 120, 193)",
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "show" : false
+ },
+ "cacheTimeout" : null,
+ "nullPointMode" : "connected",
+ "maxDataPoints" : "",
+ "colorBackground" : true,
+ "format" : "none",
+ "tableColumn" : "",
+ "id" : 59,
+ "mappingType" : 1,
+ "hideTimeOverride" : true,
+ "interval" : null,
+ "prefixFontSize" : "50%",
+ "thresholds" : "1,2",
+ "minSpan" : 1,
+ "gauge" : {
+ "show" : false,
+ "minValue" : 0,
+ "maxValue" : 100,
+ "thresholdMarkers" : true,
+ "thresholdLabels" : false
+ },
+ "nullText" : null,
+ "timeFrom" : "1m",
+ "datasource" : "Local",
+ "valueName" : "current",
+ "postfix" : "",
+ "targets" : [
+ {
+ "textEditor" : true,
+ "refId" : "A",
+ "target" : "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.deep_scrub),\"maxSeries\"))"
+ }
+ ],
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "from" : "null",
+ "to" : "null"
+ }
+ ],
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ]
+ },
+ {
+ "description" : "With the recovery flag enabled, disruption in the cluster will result in data being recreated to freespace within the cluster to honor the pool's protection schema. Under some circumstances, you may use the norecover flag to prevent automatic recovery.",
+ "valueFontSize" : "40%",
+ "prefix" : "",
+ "height" : "95",
+ "links" : [],
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "colorValue" : false,
+ "valueMaps" : [
+ {
+ "text" : "N/A",
+ "value" : "null",
+ "op" : "="
+ },
+ {
+ "value" : "0",
+ "text" : "ENABLED",
+ "op" : "="
+ },
+ {
+ "text" : "ACTIVE",
+ "value" : "1",
+ "op" : "="
+ },
+ {
+ "value" : "2",
+ "text" : "DISABLED",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "text" : "NODATA",
+ "value" : "-1"
+ }
+ ],
+ "span" : 1,
+ "tableColumn" : "",
+ "id" : 60,
+ "hideTimeOverride" : true,
+ "mappingType" : 1,
+ "colorBackground" : true,
+ "format" : "none",
+ "title" : "RECOVERY",
+ "sparkline" : {
+ "lineColor" : "rgb(31, 120, 193)",
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "show" : false
+ },
+ "maxDataPoints" : "",
+ "nullPointMode" : "connected",
+ "cacheTimeout" : null,
+ "type" : "singlestat",
+ "postfixFontSize" : "50%",
+ "nullText" : null,
+ "gauge" : {
+ "show" : false,
+ "maxValue" : 100,
+ "minValue" : 0,
+ "thresholdMarkers" : true,
+ "thresholdLabels" : false
+ },
+ "interval" : null,
+ "minSpan" : 1,
+ "thresholds" : "1,2",
+ "prefixFontSize" : "50%",
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "rangeMaps" : [
+ {
+ "from" : "null",
+ "to" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "targets" : [
+ {
+ "target" : "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.recovery),\"maxSeries\"))",
+ "refId" : "A",
+ "textEditor" : true
+ }
+ ],
+ "postfix" : "",
+ "timeFrom" : "1m",
+ "datasource" : "Local",
+ "valueName" : "current"
+ },
+ {
+ "height" : "95",
+ "prefix" : "",
+ "valueFontSize" : "40%",
+ "colorValue" : false,
+ "links" : [],
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "span" : 1,
+ "valueMaps" : [
+ {
+ "text" : "N/A",
+ "value" : "null",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "text" : "ENABLED",
+ "value" : "0"
+ },
+ {
+ "text" : "ACTIVE",
+ "value" : "1",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "text" : "DISABLED",
+ "value" : "2"
+ }
+ ],
+ "colorBackground" : true,
+ "format" : "none",
+ "tableColumn" : "",
+ "id" : 64,
+ "mappingType" : 1,
+ "hideTimeOverride" : true,
+ "type" : "singlestat",
+ "postfixFontSize" : "50%",
+ "sparkline" : {
+ "lineColor" : "rgb(31, 120, 193)",
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "show" : false
+ },
+ "title" : "BACKFILL",
+ "cacheTimeout" : null,
+ "maxDataPoints" : "",
+ "nullPointMode" : "connected",
+ "gauge" : {
+ "thresholdMarkers" : true,
+ "thresholdLabels" : false,
+ "show" : false,
+ "minValue" : 0,
+ "maxValue" : 100
+ },
+ "nullText" : null,
+ "interval" : null,
+ "prefixFontSize" : "50%",
+ "thresholds" : "1,2",
+ "minSpan" : 1,
+ "targets" : [
+ {
+ "textEditor" : true,
+ "refId" : "A",
+ "target" : "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.backfill),\"maxSeries\"))"
+ }
+ ],
+ "rangeMaps" : [
+ {
+ "from" : "null",
+ "to" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "datasource" : "Local",
+ "timeFrom" : "1m",
+ "valueName" : "current",
+ "postfix" : ""
+ },
+ {
+ "rangeMaps" : [
+ {
+ "to" : "null",
+ "from" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "targets" : [
+ {
+ "textEditor" : true,
+ "refId" : "A",
+ "target" : "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.rebalance),\"maxSeries\"))"
+ }
+ ],
+ "postfix" : "",
+ "valueName" : "current",
+ "timeFrom" : "1m",
+ "datasource" : "Local",
+ "nullText" : null,
+ "gauge" : {
+ "maxValue" : 100,
+ "minValue" : 0,
+ "show" : false,
+ "thresholdLabels" : false,
+ "thresholdMarkers" : true
+ },
+ "prefixFontSize" : "50%",
+ "thresholds" : "1,2",
+ "minSpan" : 1,
+ "interval" : null,
+ "mappingType" : 1,
+ "hideTimeOverride" : true,
+ "id" : 61,
+ "tableColumn" : "",
+ "format" : "none",
+ "colorBackground" : true,
+ "cacheTimeout" : null,
+ "maxDataPoints" : "",
+ "nullPointMode" : "connected",
+ "sparkline" : {
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : false
+ },
+ "title" : "REBALANCE",
+ "postfixFontSize" : "50%",
+ "type" : "singlestat",
+ "prefix" : "",
+ "valueFontSize" : "40%",
+ "height" : "95",
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "value" : "null",
+ "text" : "N/A"
+ },
+ {
+ "text" : "ENABLED",
+ "value" : "0",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "text" : "ACTIVE",
+ "value" : "1"
+ },
+ {
+ "text" : "DISABLED",
+ "value" : "2",
+ "op" : "="
+ },
+ {
+ "text" : "NODATA",
+ "value" : "-1",
+ "op" : "="
+ }
+ ],
+ "span" : 1,
+ "colorValue" : false,
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "value" : 2,
+ "name" : "range to text"
+ }
+ ],
+ "links" : []
+ },
+ {
+ "valueName" : "current",
+ "datasource" : "Local",
+ "timeFrom" : "1m",
+ "postfix" : "",
+ "targets" : [
+ {
+ "textEditor" : true,
+ "refId" : "A",
+ "target" : "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.out),\"maxSeries\"))"
+ }
+ ],
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "to" : "null",
+ "from" : "null"
+ }
+ ],
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "thresholds" : "1,2",
+ "prefixFontSize" : "50%",
+ "minSpan" : 1,
+ "interval" : null,
+ "gauge" : {
+ "thresholdMarkers" : true,
+ "thresholdLabels" : false,
+ "minValue" : 0,
+ "maxValue" : 100,
+ "show" : false
+ },
+ "nullText" : null,
+ "postfixFontSize" : "50%",
+ "type" : "singlestat",
+ "cacheTimeout" : null,
+ "nullPointMode" : "connected",
+ "maxDataPoints" : "",
+ "title" : "OUT",
+ "sparkline" : {
+ "show" : false,
+ "lineColor" : "rgb(31, 120, 193)",
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false
+ },
+ "format" : "none",
+ "colorBackground" : true,
+ "mappingType" : 1,
+ "hideTimeOverride" : true,
+ "id" : 62,
+ "tableColumn" : "",
+ "span" : 1,
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "value" : "null",
+ "text" : "N/A"
+ },
+ {
+ "op" : "=",
+ "text" : "ENABLED",
+ "value" : "0"
+ },
+ {
+ "value" : "1",
+ "text" : "ACTIVE",
+ "op" : "="
+ },
+ {
+ "text" : "DISABLED",
+ "value" : "2",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "value" : "-1",
+ "text" : "NODATA"
+ }
+ ],
+ "colorValue" : false,
+ "links" : [],
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "height" : "95",
+ "prefix" : "",
+ "valueFontSize" : "40%",
+ "description" : "The OUT flag setting allows the mon's to mark OSD's as out of the configuration when they stop sending hearbeats to the mon's. By marking them OUT, recovery takes place. However, for planned maintenance you can set the cluster to noout to disable this behavior."
+ },
+ {
+ "colorValue" : false,
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "value" : 2,
+ "name" : "range to text"
+ }
+ ],
+ "links" : [],
+ "span" : 1,
+ "valueMaps" : [
+ {
+ "value" : "null",
+ "text" : "N/A",
+ "op" : "="
+ },
+ {
+ "text" : "ENABLED",
+ "value" : "0",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "text" : "ACTIVE",
+ "value" : "1"
+ },
+ {
+ "text" : "DISABLED",
+ "value" : "2",
+ "op" : "="
+ },
+ {
+ "value" : "-1",
+ "text" : "NODATA",
+ "op" : "="
+ }
+ ],
+ "height" : "95",
+ "description" : "The down feature allows OSD's to mark their peers as DOWN when they are not reachable. However, if there is a poor network or planned outages, you may want to set this flag to nodown to prevent OSD's flapping between up/down states",
+ "prefix" : "",
+ "valueFontSize" : "40%",
+ "type" : "singlestat",
+ "postfixFontSize" : "50%",
+ "sparkline" : {
+ "lineColor" : "rgb(31, 120, 193)",
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "show" : false
+ },
+ "title" : "DOWN",
+ "cacheTimeout" : null,
+ "nullPointMode" : "connected",
+ "maxDataPoints" : "",
+ "colorBackground" : true,
+ "format" : "none",
+ "tableColumn" : "",
+ "id" : 63,
+ "mappingType" : 1,
+ "hideTimeOverride" : true,
+ "interval" : null,
+ "prefixFontSize" : "50%",
+ "thresholds" : "1,2",
+ "minSpan" : 1,
+ "gauge" : {
+ "thresholdMarkers" : true,
+ "thresholdLabels" : false,
+ "show" : false,
+ "minValue" : 0,
+ "maxValue" : 100
+ },
+ "nullText" : null,
+ "datasource" : "Local",
+ "timeFrom" : "1m",
+ "valueName" : "current",
+ "postfix" : "",
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.down),\"maxSeries\"))",
+ "textEditor" : true
+ }
+ ],
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "to" : "null",
+ "from" : "null"
+ }
+ ],
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ]
+ }
+ ],
+ "titleSize" : "h5"
+ },
+ {
+ "title" : "Cluster Capacity",
+ "repeatIteration" : null,
+ "titleSize" : "h5",
+ "panels" : [
+ {
+ "stack" : false,
+ "pointradius" : 5,
+ "steppedLine" : false,
+ "points" : false,
+ "tooltip" : {
+ "value_type" : "individual",
+ "shared" : true,
+ "sort" : 1
+ },
+ "renderer" : "flot",
+ "thresholds" : [],
+ "minSpan" : 6,
+ "fill" : 1,
+ "timeShift" : null,
+ "targets" : [
+ {
+ "alias" : "Used",
+ "select" : [
+ [
+ {
+ "params" : [
+ "value"
+ ],
+ "type" : "field"
+ }
+ ]
+ ],
+ "tags" : [],
+ "refId" : "B",
+ "policy" : "default",
+ "textEditor" : true,
+ "resultFormat" : "time_series",
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.osd_bytes_used",
+ "target" : "alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used), 'Used')",
+ "groupBy" : [],
+ "dsType" : "influxdb"
+ },
+ {
+ "target" : "alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes), 'Raw')",
+ "dsType" : "influxdb",
+ "groupBy" : [],
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.osd_bytes",
+ "resultFormat" : "time_series",
+ "textEditor" : true,
+ "policy" : "default",
+ "refId" : "A",
+ "tags" : [],
+ "select" : [
+ [
+ {
+ "params" : [
+ "value"
+ ],
+ "type" : "field"
+ }
+ ]
+ ],
+ "alias" : "Raw Capacity"
+ }
+ ],
+ "bars" : false,
+ "legend" : {
+ "total" : false,
+ "max" : false,
+ "current" : true,
+ "show" : true,
+ "avg" : false,
+ "min" : false,
+ "values" : true
+ },
+ "dashLength" : 10,
+ "datasource" : "Local",
+ "timeFrom" : "7d",
+ "seriesOverrides" : [],
+ "percentage" : false,
+ "spaceLength" : 10,
+ "linewidth" : 1,
+ "description" : "Shows the Capacity within the cluster over the past 7 days",
+ "span" : 6,
+ "dashes" : false,
+ "lines" : true,
+ "yaxes" : [
+ {
+ "show" : true,
+ "min" : "0",
+ "logBase" : 1,
+ "format" : "decbytes",
+ "label" : null,
+ "max" : null
+ },
+ {
+ "min" : null,
+ "show" : false,
+ "label" : null,
+ "max" : null,
+ "format" : "short",
+ "logBase" : 1
+ }
+ ],
+ "links" : [],
+ "aliasColors" : {
+ "Raw" : "#3F6833",
+ "Used" : "#E0752D"
+ },
+ "hideTimeOverride" : true,
+ "id" : 3,
+ "xaxis" : {
+ "buckets" : null,
+ "name" : null,
+ "values" : [],
+ "show" : true,
+ "mode" : "time"
+ },
+ "type" : "graph",
+ "nullPointMode" : "connected",
+ "title" : "Cluster Capacity - Past 7 Days"
+ },
+ {
+ "bars" : false,
+ "targets" : [
+ {
+ "select" : [
+ [
+ {
+ "params" : [
+ "value"
+ ],
+ "type" : "field"
+ }
+ ]
+ ],
+ "alias" : "Used",
+ "tags" : [],
+ "refId" : "B",
+ "policy" : "default",
+ "textEditor" : true,
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.osd_bytes_used",
+ "target" : "alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_object), 'RADOS Objects')",
+ "dsType" : "influxdb",
+ "groupBy" : [],
+ "resultFormat" : "time_series"
+ }
+ ],
+ "percentage" : false,
+ "seriesOverrides" : [],
+ "legend" : {
+ "max" : false,
+ "total" : false,
+ "values" : true,
+ "min" : false,
+ "avg" : false,
+ "show" : true,
+ "current" : true
+ },
+ "timeFrom" : "7d",
+ "datasource" : "Local",
+ "dashLength" : 10,
+ "steppedLine" : false,
+ "points" : false,
+ "stack" : false,
+ "pointradius" : 5,
+ "timeShift" : null,
+ "minSpan" : 6,
+ "fill" : 1,
+ "thresholds" : [],
+ "tooltip" : {
+ "sort" : 1,
+ "shared" : true,
+ "value_type" : "individual"
+ },
+ "renderer" : "flot",
+ "hideTimeOverride" : true,
+ "id" : 65,
+ "xaxis" : {
+ "buckets" : null,
+ "name" : null,
+ "values" : [],
+ "show" : true,
+ "mode" : "time"
+ },
+ "decimals" : 2,
+ "nullPointMode" : "connected",
+ "title" : "RADOS Object History - Past 7 Days",
+ "type" : "graph",
+ "description" : "Shows the Capacity within the cluster over the past 7 days",
+ "linewidth" : 1,
+ "spaceLength" : 10,
+ "span" : 6,
+ "yaxes" : [
+ {
+ "min" : "0",
+ "show" : true,
+ "label" : "RADOS Object Count",
+ "max" : null,
+ "format" : "short",
+ "logBase" : 1
+ },
+ {
+ "format" : "short",
+ "logBase" : 1,
+ "max" : null,
+ "label" : null,
+ "show" : false,
+ "min" : null
+ }
+ ],
+ "links" : [],
+ "lines" : true,
+ "aliasColors" : {
+ "Raw" : "#3F6833",
+ "Used" : "#E0752D"
+ },
+ "dashes" : false
+ }
+ ],
+ "repeatRowId" : null,
+ "height" : "250",
+ "collapse" : true,
+ "repeat" : null,
+ "showTitle" : true
+ },
+ {
+ "title" : "Ceph Version Configuration",
+ "repeatIteration" : null,
+ "repeatRowId" : null,
+ "titleSize" : "h5",
+ "panels" : [
+ {
+ "sort" : {
+ "col" : 0,
+ "desc" : true
+ },
+ "hideTimeOverride" : true,
+ "id" : 75,
+ "targets" : [
+ {
+ "target" : "aliasByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.ceph_version, 1)",
+ "refId" : "A"
+ }
+ ],
+ "title" : "MON Versions",
+ "timeFrom" : "2m",
+ "type" : "table",
+ "styles" : [
+ {
+ "pattern" : "Time",
+ "alias" : "Time",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "type" : "date"
+ },
+ {
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "pattern" : "Current",
+ "colorMode" : null,
+ "decimals" : 1,
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "unit" : "short",
+ "thresholds" : [],
+ "type" : "number",
+ "alias" : "Version"
+ },
+ {
+ "thresholds" : [],
+ "unit" : "short",
+ "alias" : "Host",
+ "type" : "number",
+ "decimals" : 2,
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "colorMode" : null,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "pattern" : "Metric"
+ },
+ {
+ "decimals" : 2,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "pattern" : "/.*/",
+ "colorMode" : null,
+ "type" : "number",
+ "alias" : "",
+ "unit" : "short",
+ "thresholds" : []
+ }
+ ],
+ "columns" : [
+ {
+ "value" : "current",
+ "text" : "Current"
+ }
+ ],
+ "showHeader" : true,
+ "scroll" : true,
+ "pageSize" : 10,
+ "fontSize" : "100%",
+ "timeShift" : null,
+ "span" : 2,
+ "minSpan" : 2,
+ "transform" : "timeseries_aggregations",
+ "links" : []
+ },
+ {
+ "title" : "",
+ "content" : "",
+ "type" : "text",
+ "links" : [],
+ "minSpan" : 1,
+ "span" : 1,
+ "id" : 79,
+ "mode" : "markdown",
+ "transparent" : true
+ },
+ {
+ "timeShift" : null,
+ "fontSize" : "100%",
+ "pageSize" : 10,
+ "links" : [],
+ "transform" : "timeseries_aggregations",
+ "minSpan" : 2,
+ "span" : 2,
+ "showHeader" : true,
+ "columns" : [
+ {
+ "text" : "Current",
+ "value" : "current"
+ }
+ ],
+ "styles" : [
+ {
+ "pattern" : "Time",
+ "alias" : "Time",
+ "type" : "date",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss"
+ },
+ {
+ "thresholds" : [],
+ "unit" : "short",
+ "alias" : "Version",
+ "type" : "number",
+ "decimals" : 1,
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "colorMode" : null,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "pattern" : "Current"
+ },
+ {
+ "type" : "number",
+ "alias" : "Host",
+ "unit" : "short",
+ "thresholds" : [],
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "decimals" : 2,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "pattern" : "Metric",
+ "colorMode" : null
+ },
+ {
+ "thresholds" : [],
+ "unit" : "short",
+ "alias" : "",
+ "type" : "number",
+ "colorMode" : null,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "pattern" : "/.*/",
+ "decimals" : 2
+ }
+ ],
+ "scroll" : true,
+ "title" : "OSD Versions",
+ "timeFrom" : "2m",
+ "type" : "table",
+ "id" : 76,
+ "sort" : {
+ "col" : 0,
+ "desc" : true
+ },
+ "hideTimeOverride" : true,
+ "targets" : [
+ {
+ "target" : "aliasByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.ceph_version, 1)",
+ "refId" : "A"
+ }
+ ]
+ },
+ {
+ "mode" : "markdown",
+ "transparent" : true,
+ "id" : 80,
+ "type" : "text",
+ "links" : [],
+ "span" : 1,
+ "minSpan" : 1,
+ "title" : "",
+ "content" : ""
+ },
+ {
+ "hideTimeOverride" : true,
+ "sort" : {
+ "desc" : true,
+ "col" : 0
+ },
+ "id" : 77,
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : "aliasByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.rgw.select metric, 1)",
+ "textEditor" : true
+ }
+ ],
+ "title" : "RGW Versions",
+ "timeFrom" : "2m",
+ "type" : "table",
+ "styles" : [
+ {
+ "alias" : "Time",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "type" : "date",
+ "pattern" : "Time"
+ },
+ {
+ "pattern" : "Current",
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "colorMode" : null,
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "decimals" : 1,
+ "type" : "number",
+ "alias" : "Version",
+ "unit" : "short",
+ "thresholds" : []
+ },
+ {
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "decimals" : 2,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "pattern" : "Metric",
+ "colorMode" : null,
+ "type" : "number",
+ "alias" : "Host",
+ "unit" : "short",
+ "thresholds" : []
+ },
+ {
+ "decimals" : 2,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "pattern" : "/.*/",
+ "colorMode" : null,
+ "type" : "number",
+ "alias" : "",
+ "unit" : "short",
+ "thresholds" : []
+ }
+ ],
+ "showHeader" : true,
+ "columns" : [
+ {
+ "text" : "Current",
+ "value" : "current"
+ }
+ ],
+ "scroll" : true,
+ "fontSize" : "100%",
+ "pageSize" : 10,
+ "span" : 2,
+ "minSpan" : 2,
+ "links" : [],
+ "transform" : "timeseries_aggregations"
+ },
+ {
+ "mode" : "markdown",
+ "transparent" : true,
+ "id" : 81,
+ "links" : [],
+ "type" : "text",
+ "span" : 1,
+ "minSpan" : 1,
+ "title" : "",
+ "content" : ""
+ },
+ {
+ "fontSize" : "100%",
+ "pageSize" : 10,
+ "minSpan" : 2,
+ "span" : 2,
+ "links" : [],
+ "transform" : "timeseries_aggregations",
+ "styles" : [
+ {
+ "pattern" : "Time",
+ "type" : "date",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "alias" : "Time"
+ },
+ {
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "decimals" : 1,
+ "pattern" : "Current",
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "colorMode" : null,
+ "type" : "number",
+ "alias" : "Version",
+ "unit" : "short",
+ "thresholds" : []
+ },
+ {
+ "pattern" : "Metric",
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "colorMode" : null,
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "decimals" : 2,
+ "type" : "number",
+ "alias" : "Host",
+ "unit" : "short",
+ "thresholds" : []
+ },
+ {
+ "decimals" : 2,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "pattern" : "/.*/",
+ "colorMode" : null,
+ "unit" : "short",
+ "thresholds" : [],
+ "type" : "number",
+ "alias" : ""
+ }
+ ],
+ "columns" : [
+ {
+ "text" : "Current",
+ "value" : "current"
+ }
+ ],
+ "showHeader" : true,
+ "scroll" : true,
+ "title" : "iSCSI Versions",
+ "type" : "table",
+ "timeFrom" : "2m",
+ "sort" : {
+ "desc" : true,
+ "col" : 0
+ },
+ "hideTimeOverride" : true,
+ "id" : 78,
+ "targets" : [
+ {
+ "textEditor" : true,
+ "target" : "aliasByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.iscsi.select metric, 1)",
+ "refId" : "A"
+ }
+ ]
+ }
+ ],
+ "repeat" : null,
+ "showTitle" : true,
+ "collapse" : true,
+ "height" : 250
+ }
+ ],
+ "graphTooltip" : 0,
+ "schemaVersion" : 14,
+ "timepicker" : {
+ "refresh_intervals" : [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options" : [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "links" : [
+ {
+ "type" : "dashboards",
+ "targetBlank" : true,
+ "keepTime" : true,
+ "tags" : [
+ "overview"
+ ],
+ "title" : "Shortcuts",
+ "icon" : "external link",
+ "asDropdown" : true,
+ "includeVars" : true
+ }
+ ],
+ "timezone" : "browser",
+ "refresh" : "10s",
+ "tags" : [
+ "overview"
+ ],
+ "gnetId" : null,
+ "hideControls" : true,
+ "templating" : {
+ "list" : [
+ {
+ "useTags" : false,
+ "tagsQuery" : "",
+ "allValue" : null,
+ "tagValuesQuery" : "",
+ "name" : "cluster_name",
+ "refresh" : 1,
+ "tags" : [],
+ "type" : "query",
+ "datasource" : "Local",
+ "multi" : false,
+ "query" : "collectd.*.$domain.cephmetrics.gauge.*",
+ "current" : {
+ "text" : "ceph",
+ "selected" : true,
+ "value" : "ceph"
+ },
+ "label" : null,
+ "hide" : 2,
+ "includeAll" : false,
+ "options" : [],
+ "sort" : 0,
+ "regex" : ""
+ },
+ {
+ "label" : null,
+ "hide" : 2,
+ "options" : [
+ {
+ "value" : "test.lab",
+ "selected" : true,
+ "text" : "test.lab"
+ }
+ ],
+ "includeAll" : false,
+ "query" : "test.lab",
+ "allValue" : null,
+ "multi" : false,
+ "type" : "custom",
+ "current" : {
+ "text" : "test.lab",
+ "selected" : true,
+ "value" : "test.lab"
+ },
+ "name" : "domain"
+ }
+ ]
+ },
+ "time" : {
+ "from" : "now-1h",
+ "to" : "now"
+ },
+ "title" : "Ceph Cluster",
+ "editable" : false,
+ "annotations" : {
+ "list" : []
+ },
+ "version" : 28,
+ "style" : "dark",
+ "id" : 25
+ },
+ "meta" : {
+ "canStar" : true,
+ "canEdit" : true,
+ "created" : "2017-08-03T21:42:28Z",
+ "createdBy" : "admin",
+ "type" : "db",
+ "canSave" : true,
+ "updatedBy" : "admin",
+ "updated" : "2017-08-19T00:15:45Z",
+ "slug" : "ceph-cluster",
+ "expires" : "0001-01-01T00:00:00Z",
+ "version" : 28
+ }
+}
--- /dev/null
+{
+ "dashboard" : {
+ "id" : 29,
+ "links" : [
+ {
+ "type" : "dashboards",
+ "tags" : [
+ "overview"
+ ],
+ "icon" : "external link",
+ "title" : "Shortcuts",
+ "asDropdown" : true,
+ "targetBlank" : true,
+ "includeVars" : true,
+ "keepTime" : true
+ }
+ ],
+ "time" : {
+ "to" : "now",
+ "from" : "now-1h"
+ },
+ "annotations" : {
+ "list" : [
+ {
+ "tags" : "health_alert",
+ "type" : "alert",
+ "showIn" : 0,
+ "limit" : 100,
+ "iconColor" : "rgba(255, 96, 96, 1)",
+ "enable" : true,
+ "datasource" : "Local",
+ "hide" : false,
+ "name" : "health_alert"
+ },
+ {
+ "enable" : true,
+ "hide" : false,
+ "name" : "health_ok",
+ "datasource" : "Local",
+ "limit" : 100,
+ "iconColor" : "rgb(1, 195, 0)",
+ "showIn" : 0,
+ "tags" : "health_ok",
+ "type" : "alert"
+ }
+ ]
+ },
+ "style" : "dark",
+ "templating" : {
+ "list" : [
+ {
+ "regex" : "",
+ "useTags" : false,
+ "tags" : [],
+ "sort" : 0,
+ "query" : "collectd.*.$domain.cephmetrics.gauge.*",
+ "datasource" : "Local",
+ "name" : "cluster_name",
+ "hide" : 2,
+ "tagValuesQuery" : "",
+ "refresh" : 1,
+ "tagsQuery" : "",
+ "allValue" : null,
+ "type" : "query",
+ "current" : {
+ "text" : "ceph",
+ "value" : "ceph",
+ "selected" : true
+ },
+ "multi" : false,
+ "includeAll" : false,
+ "options" : [],
+ "label" : null
+ },
+ {
+ "type" : "custom",
+ "query" : "test.lab",
+ "current" : {
+ "value" : "test.lab",
+ "text" : "test.lab",
+ "selected" : true
+ },
+ "allValue" : null,
+ "options" : [
+ {
+ "value" : "test.lab",
+ "text" : "test.lab",
+ "selected" : true
+ }
+ ],
+ "label" : null,
+ "multi" : false,
+ "hide" : 2,
+ "includeAll" : false,
+ "name" : "domain"
+ },
+ {
+ "current" : {
+ "selected" : true,
+ "text" : "All",
+ "value" : "$__all"
+ },
+ "query" : "ceph-1,ceph-2,ceph-3",
+ "type" : "custom",
+ "allValue" : null,
+ "name" : "osd_servers",
+ "hide" : 2,
+ "includeAll" : true,
+ "multi" : true,
+ "options" : [
+ {
+ "text" : "All",
+ "value" : "$__all",
+ "selected" : true
+ },
+ {
+ "value" : "ceph-1",
+ "text" : "ceph-1",
+ "selected" : false
+ },
+ {
+ "text" : "ceph-2",
+ "value" : "ceph-2",
+ "selected" : false
+ },
+ {
+ "value" : "ceph-3",
+ "text" : "ceph-3",
+ "selected" : false
+ }
+ ],
+ "label" : null
+ },
+ {
+ "allValue" : null,
+ "query" : "85",
+ "current" : {
+ "text" : "85",
+ "value" : "85",
+ "selected" : true
+ },
+ "type" : "custom",
+ "name" : "disk_full_threshold",
+ "hide" : 2,
+ "includeAll" : false,
+ "multi" : false,
+ "options" : [
+ {
+ "selected" : true,
+ "value" : "85",
+ "text" : "85"
+ }
+ ],
+ "label" : null
+ }
+ ]
+ },
+ "gnetId" : null,
+ "tags" : [
+ "overview"
+ ],
+ "rows" : [
+ {
+ "repeatRowId" : null,
+ "height" : "70",
+ "title" : "Dashboard Row",
+ "collapse" : false,
+ "repeat" : null,
+ "titleSize" : "h6",
+ "showTitle" : false,
+ "panels" : [
+ {
+ "span" : 12,
+ "nullText" : null,
+ "timeShift" : null,
+ "title" : "",
+ "datasource" : "Local",
+ "gauge" : {
+ "maxValue" : 100,
+ "thresholdLabels" : false,
+ "show" : false,
+ "minValue" : 0,
+ "thresholdMarkers" : true
+ },
+ "links" : [],
+ "rangeMaps" : [
+ {
+ "from" : "0",
+ "to" : "1",
+ "text" : "HEALTH OK"
+ },
+ {
+ "text" : "HEALTH WARNING",
+ "from" : "1",
+ "to" : "4"
+ },
+ {
+ "text" : "HEALTH ERROR",
+ "to" : "99",
+ "from" : "5"
+ },
+ {
+ "from" : "-10",
+ "to" : "0",
+ "text" : "NODATA"
+ }
+ ],
+ "mappingType" : 2,
+ "height" : "70",
+ "interval" : null,
+ "prefixFontSize" : "50%",
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "value" : "0",
+ "text" : "OK"
+ },
+ {
+ "op" : "=",
+ "value" : "4",
+ "text" : "WARN"
+ },
+ {
+ "value" : "8",
+ "text" : "ERROR",
+ "op" : "="
+ }
+ ],
+ "tableColumn" : "",
+ "colorValue" : false,
+ "timeFrom" : "1m",
+ "nullPointMode" : "connected",
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "value" : 2,
+ "name" : "range to text"
+ }
+ ],
+ "type" : "singlestat",
+ "maxDataPoints" : "",
+ "format" : "none",
+ "colors" : [
+ "rgba(1, 167, 1, 1)",
+ "rgba(255,165,0, 1)",
+ "rgba(255, 0, 0, 1)"
+ ],
+ "minSpan" : 1,
+ "description" : "Shows the overall health of the ceph cluster. To see specific health messages hover over the annotation in the health chart below.",
+ "cacheTimeout" : null,
+ "valueName" : "current",
+ "id" : 76,
+ "thresholds" : "1,5",
+ "sparkline" : {
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : false,
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)"
+ },
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : "consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.health),\"max\")",
+ "textEditor" : true
+ }
+ ],
+ "valueFontSize" : "50%",
+ "postfix" : "",
+ "hideTimeOverride" : true,
+ "postfixFontSize" : "50%",
+ "prefix" : "",
+ "colorBackground" : true
+ }
+ ],
+ "repeatIteration" : null
+ },
+ {
+ "repeat" : null,
+ "repeatRowId" : null,
+ "height" : "350",
+ "collapse" : false,
+ "title" : "Cluster Health",
+ "showTitle" : true,
+ "panels" : [
+ {
+ "spaceLength" : 10,
+ "targets" : [
+ {
+ "textEditor" : true,
+ "target" : "alias(maxSeries(summarize(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.health,\"5min\",\"max\")), 'Ceph Health')",
+ "refId" : "A"
+ }
+ ],
+ "yaxes" : [
+ {
+ "format" : "short",
+ "logBase" : 1,
+ "show" : false,
+ "label" : "",
+ "max" : "10",
+ "min" : "-1"
+ },
+ {
+ "max" : null,
+ "min" : null,
+ "label" : null,
+ "logBase" : 1,
+ "show" : false,
+ "format" : "short"
+ }
+ ],
+ "lines" : true,
+ "points" : false,
+ "steppedLine" : true,
+ "hideTimeOverride" : true,
+ "description" : "The chart plots the clusters health, over time. Health is depicted as a integer; 0, 4 or 8 where 0 is OK, 4 is WARN and 8 represents an ERROR state. Horizontal thresholds (drawn in yellow and red) indicate when the cluster's health transitions to 'warning' or 'error'. Annotations describing the details of the clusters health may also be shown if the \"EventURL\" setting is defined to the collectd plugin on the mon hosts.",
+ "bars" : false,
+ "minSpan" : 3,
+ "renderer" : "flot",
+ "thresholds" : [
+ {
+ "op" : "gt",
+ "line" : true,
+ "fill" : false,
+ "lineColor" : "rgb(247, 172, 0)",
+ "value" : 3,
+ "colorMode" : "custom",
+ "fillColor" : "rgba(222, 226, 0, 0.47)"
+ },
+ {
+ "op" : "gt",
+ "fill" : false,
+ "line" : true,
+ "lineColor" : "rgb(203, 0, 0)",
+ "value" : 7,
+ "colorMode" : "custom",
+ "fillColor" : "rgba(246, 3, 3, 0.5)"
+ }
+ ],
+ "dashLength" : 10,
+ "id" : 55,
+ "nullPointMode" : "null",
+ "timeFrom" : "3d",
+ "xaxis" : {
+ "mode" : "time",
+ "buckets" : null,
+ "name" : null,
+ "show" : true,
+ "values" : []
+ },
+ "aliasColors" : {
+ "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.health" : "#DEDAF7",
+ "Ceph Health" : "#3F6833",
+ "Ceph Health (0:OK, 4:Warning,8:Error)" : "#DEDAF7"
+ },
+ "height" : "350",
+ "fill" : 1,
+ "linewidth" : 2,
+ "maxDataPoints" : "",
+ "percentage" : false,
+ "type" : "graph",
+ "tooltip" : {
+ "sort" : 1,
+ "shared" : false,
+ "value_type" : "individual"
+ },
+ "datasource" : "Local",
+ "seriesOverrides" : [],
+ "timeShift" : null,
+ "title" : "Health History - Last 3 days",
+ "pointradius" : 5,
+ "span" : 12,
+ "stack" : false,
+ "legend" : {
+ "values" : false,
+ "max" : false,
+ "min" : false,
+ "total" : false,
+ "avg" : false,
+ "current" : false,
+ "show" : true
+ },
+ "dashes" : false,
+ "links" : []
+ }
+ ],
+ "repeatIteration" : null,
+ "titleSize" : "h5"
+ },
+ {
+ "repeatIteration" : null,
+ "panels" : [
+ {
+ "content" : "",
+ "links" : [],
+ "id" : 69,
+ "type" : "text",
+ "transparent" : true,
+ "mode" : "html",
+ "span" : 1,
+ "minSpan" : 1,
+ "title" : ""
+ },
+ {
+ "columns" : [
+ {
+ "value" : "current",
+ "text" : "Current"
+ }
+ ],
+ "id" : 56,
+ "links" : [],
+ "sort" : {
+ "desc" : false,
+ "col" : null
+ },
+ "styles" : [
+ {
+ "type" : "date",
+ "alias" : "Time",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "pattern" : "Time"
+ },
+ {
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "unit" : "short",
+ "pattern" : "Metric",
+ "sanitize" : false,
+ "alias" : "Hostname",
+ "type" : "number",
+ "colorMode" : null,
+ "thresholds" : [],
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals" : 2
+ },
+ {
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(0, 169, 3, 0.89)",
+ "rgba(249, 190, 0, 0.97)"
+ ],
+ "decimals" : 0,
+ "type" : "number",
+ "alias" : "Status",
+ "colorMode" : "row",
+ "thresholds" : [
+ "0",
+ "3",
+ "7"
+ ],
+ "unit" : "short",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "pattern" : "Current"
+ },
+ {
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals" : 2,
+ "unit" : "short",
+ "pattern" : "/.*/",
+ "alias" : "",
+ "type" : "number",
+ "thresholds" : [],
+ "colorMode" : null
+ }
+ ],
+ "span" : 3,
+ "title" : "Monitor Status",
+ "timeShift" : null,
+ "minSpan" : 2,
+ "fontSize" : "100%",
+ "maxDataPoints" : "",
+ "hideTimeOverride" : true,
+ "type" : "table",
+ "transform" : "timeseries_aggregations",
+ "timeFrom" : "1m",
+ "pageSize" : null,
+ "showHeader" : true,
+ "targets" : [
+ {
+ "refId" : "B",
+ "target" : "aliasByNode(groupByNode(transformNull(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.mon_status.*),-1),-1,\"maxSeries\"),-1)",
+ "textEditor" : true
+ }
+ ],
+ "scroll" : true
+ },
+ {
+ "type" : "text",
+ "content" : "",
+ "id" : 68,
+ "links" : [],
+ "mode" : "html",
+ "transparent" : true,
+ "minSpan" : 2,
+ "title" : "",
+ "span" : 2
+ },
+ {
+ "span" : 1,
+ "minSpan" : 1,
+ "title" : "",
+ "id" : 58,
+ "links" : [],
+ "content" : "<h2 style=\"text-align: center;\">Cluster Flags:</h2>",
+ "type" : "text",
+ "mode" : "html",
+ "transparent" : true
+ },
+ {
+ "interval" : null,
+ "mappingType" : 1,
+ "height" : "95",
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "value" : 2,
+ "name" : "range to text"
+ }
+ ],
+ "colorValue" : false,
+ "nullPointMode" : "connected",
+ "timeFrom" : "1m",
+ "prefixFontSize" : "50%",
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "value" : "null",
+ "text" : "N/A"
+ },
+ {
+ "value" : "0",
+ "text" : "ENABLED",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "value" : "1",
+ "text" : "ACTIVE"
+ },
+ {
+ "value" : "2",
+ "text" : "DISABLED",
+ "op" : "="
+ }
+ ],
+ "tableColumn" : "",
+ "type" : "singlestat",
+ "maxDataPoints" : "",
+ "format" : "none",
+ "title" : "SCRUB",
+ "nullText" : null,
+ "span" : 1,
+ "gauge" : {
+ "show" : false,
+ "minValue" : 0,
+ "thresholdMarkers" : true,
+ "maxValue" : 100,
+ "thresholdLabels" : false
+ },
+ "datasource" : "Local",
+ "rangeMaps" : [
+ {
+ "to" : "null",
+ "from" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "links" : [],
+ "valueFontSize" : "40%",
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.scrub),\"maxSeries\"))",
+ "textEditor" : true
+ }
+ ],
+ "postfix" : "",
+ "postfixFontSize" : "50%",
+ "hideTimeOverride" : true,
+ "prefix" : "",
+ "colorBackground" : true,
+ "minSpan" : 1,
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "description" : "Scrub activity takes place daily basis across the OSD's and performs object size and attribute checks. Scrub activity can be controlled with the \"ceph osd scrub\" command.",
+ "thresholds" : "1,2",
+ "sparkline" : {
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false,
+ "show" : false,
+ "lineColor" : "rgb(31, 120, 193)"
+ },
+ "valueName" : "current",
+ "cacheTimeout" : null,
+ "id" : 57
+ },
+ {
+ "format" : "none",
+ "maxDataPoints" : "",
+ "type" : "singlestat",
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "value" : 2,
+ "name" : "range to text"
+ }
+ ],
+ "timeFrom" : "1m",
+ "colorValue" : false,
+ "nullPointMode" : "connected",
+ "valueMaps" : [
+ {
+ "value" : "null",
+ "text" : "N/A",
+ "op" : "="
+ },
+ {
+ "value" : "0",
+ "text" : "ENABLED",
+ "op" : "="
+ },
+ {
+ "value" : "1",
+ "text" : "ACTIVE",
+ "op" : "="
+ },
+ {
+ "text" : "DISABLED",
+ "value" : "2",
+ "op" : "="
+ }
+ ],
+ "prefixFontSize" : "50%",
+ "tableColumn" : "",
+ "interval" : null,
+ "mappingType" : 1,
+ "height" : "95",
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "from" : "null",
+ "to" : "null"
+ }
+ ],
+ "links" : [],
+ "gauge" : {
+ "show" : false,
+ "minValue" : 0,
+ "thresholdMarkers" : true,
+ "thresholdLabels" : false,
+ "maxValue" : 100
+ },
+ "datasource" : "Local",
+ "title" : "DEEP SCRUB",
+ "nullText" : null,
+ "span" : 1,
+ "colorBackground" : true,
+ "prefix" : "",
+ "postfixFontSize" : "50%",
+ "hideTimeOverride" : true,
+ "postfix" : "",
+ "valueFontSize" : "40%",
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.deep_scrub),\"maxSeries\"))",
+ "textEditor" : true
+ }
+ ],
+ "sparkline" : {
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : false
+ },
+ "thresholds" : "1,2",
+ "id" : 59,
+ "valueName" : "current",
+ "cacheTimeout" : null,
+ "description" : "Deep scrub acts on the objects within placement groups (PGs). Objects are read, and checksum's compared to protect against silent bit-rot events. Although a weekly activity, in large clusters is normal to see deep-scrub active on a daily basis. Scrub activity can be controlled with the \"ceph osd scrub\" command.",
+ "minSpan" : 1,
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ]
+ },
+ {
+ "description" : "With the recovery flag enabled, disruption in the cluster will result in data being recreated to freespace within the cluster to honor the pool's protection schema. Under some circumstances, you may use the norecover flag to prevent automatic recovery.",
+ "minSpan" : 1,
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "thresholds" : "1,2",
+ "sparkline" : {
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : false,
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)"
+ },
+ "id" : 60,
+ "valueName" : "current",
+ "cacheTimeout" : null,
+ "postfix" : "",
+ "valueFontSize" : "40%",
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.recovery),\"maxSeries\"))",
+ "textEditor" : true
+ }
+ ],
+ "prefix" : "",
+ "colorBackground" : true,
+ "postfixFontSize" : "50%",
+ "hideTimeOverride" : true,
+ "gauge" : {
+ "thresholdMarkers" : true,
+ "minValue" : 0,
+ "show" : false,
+ "thresholdLabels" : false,
+ "maxValue" : 100
+ },
+ "datasource" : "Local",
+ "title" : "RECOVERY",
+ "nullText" : null,
+ "span" : 1,
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "from" : "null",
+ "to" : "null"
+ }
+ ],
+ "links" : [],
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "value" : 2,
+ "name" : "range to text"
+ }
+ ],
+ "nullPointMode" : "connected",
+ "colorValue" : false,
+ "timeFrom" : "1m",
+ "tableColumn" : "",
+ "valueMaps" : [
+ {
+ "value" : "null",
+ "text" : "N/A",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "text" : "ENABLED",
+ "value" : "0"
+ },
+ {
+ "value" : "1",
+ "text" : "ACTIVE",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "value" : "2",
+ "text" : "DISABLED"
+ }
+ ],
+ "prefixFontSize" : "50%",
+ "interval" : null,
+ "mappingType" : 1,
+ "height" : "95",
+ "format" : "none",
+ "maxDataPoints" : "",
+ "type" : "singlestat"
+ },
+ {
+ "prefix" : "",
+ "colorBackground" : true,
+ "postfixFontSize" : "50%",
+ "hideTimeOverride" : true,
+ "postfix" : "",
+ "targets" : [
+ {
+ "textEditor" : true,
+ "target" : "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.backfill),\"maxSeries\"))",
+ "refId" : "A"
+ }
+ ],
+ "valueFontSize" : "40%",
+ "thresholds" : "1,2",
+ "sparkline" : {
+ "show" : false,
+ "lineColor" : "rgb(31, 120, 193)",
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false
+ },
+ "cacheTimeout" : null,
+ "valueName" : "current",
+ "id" : 64,
+ "minSpan" : 1,
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "format" : "none",
+ "maxDataPoints" : "",
+ "type" : "singlestat",
+ "colorValue" : false,
+ "nullPointMode" : "connected",
+ "timeFrom" : "1m",
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "valueMaps" : [
+ {
+ "value" : "null",
+ "text" : "N/A",
+ "op" : "="
+ },
+ {
+ "text" : "ENABLED",
+ "value" : "0",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "value" : "1",
+ "text" : "ACTIVE"
+ },
+ {
+ "value" : "2",
+ "text" : "DISABLED",
+ "op" : "="
+ }
+ ],
+ "prefixFontSize" : "50%",
+ "tableColumn" : "",
+ "mappingType" : 1,
+ "height" : "95",
+ "interval" : null,
+ "links" : [],
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "from" : "null",
+ "to" : "null"
+ }
+ ],
+ "gauge" : {
+ "minValue" : 0,
+ "show" : false,
+ "thresholdMarkers" : true,
+ "thresholdLabels" : false,
+ "maxValue" : 100
+ },
+ "datasource" : "Local",
+ "nullText" : null,
+ "title" : "BACKFILL",
+ "span" : 1
+ },
+ {
+ "type" : "singlestat",
+ "maxDataPoints" : "",
+ "format" : "none",
+ "interval" : null,
+ "mappingType" : 1,
+ "height" : "95",
+ "valueMaps" : [
+ {
+ "op" : "=",
+ "value" : "null",
+ "text" : "N/A"
+ },
+ {
+ "value" : "0",
+ "text" : "ENABLED",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "text" : "ACTIVE",
+ "value" : "1"
+ },
+ {
+ "value" : "2",
+ "text" : "DISABLED",
+ "op" : "="
+ }
+ ],
+ "prefixFontSize" : "50%",
+ "tableColumn" : "",
+ "mappingTypes" : [
+ {
+ "name" : "value to text",
+ "value" : 1
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "nullPointMode" : "connected",
+ "colorValue" : false,
+ "timeFrom" : "1m",
+ "rangeMaps" : [
+ {
+ "from" : "null",
+ "to" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "links" : [],
+ "span" : 1,
+ "title" : "REBALANCE",
+ "nullText" : null,
+ "datasource" : "Local",
+ "gauge" : {
+ "thresholdMarkers" : true,
+ "minValue" : 0,
+ "show" : false,
+ "thresholdLabels" : false,
+ "maxValue" : 100
+ },
+ "hideTimeOverride" : true,
+ "postfixFontSize" : "50%",
+ "prefix" : "",
+ "colorBackground" : true,
+ "valueFontSize" : "40%",
+ "targets" : [
+ {
+ "target" : "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.rebalance),\"maxSeries\"))",
+ "textEditor" : true,
+ "refId" : "A"
+ }
+ ],
+ "postfix" : "",
+ "id" : 61,
+ "valueName" : "current",
+ "cacheTimeout" : null,
+ "sparkline" : {
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false
+ },
+ "thresholds" : "1,2",
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "minSpan" : 1
+ },
+ {
+ "valueName" : "current",
+ "id" : 62,
+ "cacheTimeout" : null,
+ "thresholds" : "1,2",
+ "sparkline" : {
+ "lineColor" : "rgb(31, 120, 193)",
+ "show" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "full" : false
+ },
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "minSpan" : 1,
+ "description" : "The OUT flag setting allows the mon's to mark OSD's as out of the configuration when they stop sending hearbeats to the mon's. By marking them OUT, recovery takes place. However, for planned maintenance you can set the cluster to noout to disable this behavior.",
+ "hideTimeOverride" : true,
+ "postfixFontSize" : "50%",
+ "colorBackground" : true,
+ "prefix" : "",
+ "valueFontSize" : "40%",
+ "targets" : [
+ {
+ "target" : "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.out),\"maxSeries\"))",
+ "textEditor" : true,
+ "refId" : "A"
+ }
+ ],
+ "postfix" : "",
+ "rangeMaps" : [
+ {
+ "to" : "null",
+ "from" : "null",
+ "text" : "N/A"
+ }
+ ],
+ "links" : [],
+ "span" : 1,
+ "title" : "OUT",
+ "timeShift" : null,
+ "nullText" : null,
+ "datasource" : "Local",
+ "gauge" : {
+ "maxValue" : 100,
+ "thresholdLabels" : false,
+ "thresholdMarkers" : true,
+ "minValue" : 0,
+ "show" : false
+ },
+ "type" : "singlestat",
+ "maxDataPoints" : "",
+ "format" : "none",
+ "interval" : null,
+ "height" : "95",
+ "mappingType" : 1,
+ "valueMaps" : [
+ {
+ "text" : "N/A",
+ "value" : "null",
+ "op" : "="
+ },
+ {
+ "text" : "ENABLED",
+ "value" : "0",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "value" : "1",
+ "text" : "ACTIVE"
+ },
+ {
+ "value" : "2",
+ "text" : "DISABLED",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "value" : "-1",
+ "text" : "NODATA"
+ }
+ ],
+ "tableColumn" : "",
+ "prefixFontSize" : "50%",
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "nullPointMode" : "connected",
+ "colorValue" : false,
+ "timeFrom" : "1m"
+ },
+ {
+ "sparkline" : {
+ "full" : false,
+ "fillColor" : "rgba(31, 118, 189, 0.18)",
+ "show" : false,
+ "lineColor" : "rgb(31, 120, 193)"
+ },
+ "thresholds" : "1,2",
+ "valueName" : "current",
+ "id" : 63,
+ "cacheTimeout" : null,
+ "description" : "The down feature allows OSD's to mark their peers as DOWN when they are not reachable. However, if there is a poor network or planned outages, you may want to set this flag to nodown to prevent OSD's flapping between up/down states",
+ "minSpan" : 1,
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "prefix" : "",
+ "colorBackground" : true,
+ "postfixFontSize" : "50%",
+ "hideTimeOverride" : true,
+ "postfix" : "",
+ "targets" : [
+ {
+ "refId" : "A",
+ "textEditor" : true,
+ "target" : "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.features.down),\"maxSeries\"))"
+ }
+ ],
+ "valueFontSize" : "40%",
+ "links" : [],
+ "rangeMaps" : [
+ {
+ "text" : "N/A",
+ "from" : "null",
+ "to" : "null"
+ }
+ ],
+ "gauge" : {
+ "thresholdMarkers" : true,
+ "minValue" : 0,
+ "show" : false,
+ "maxValue" : 100,
+ "thresholdLabels" : false
+ },
+ "datasource" : "Local",
+ "nullText" : null,
+ "timeShift" : null,
+ "title" : "DOWN",
+ "span" : 1,
+ "format" : "none",
+ "maxDataPoints" : "",
+ "type" : "singlestat",
+ "nullPointMode" : "connected",
+ "colorValue" : false,
+ "timeFrom" : "1m",
+ "mappingTypes" : [
+ {
+ "value" : 1,
+ "name" : "value to text"
+ },
+ {
+ "name" : "range to text",
+ "value" : 2
+ }
+ ],
+ "tableColumn" : "",
+ "valueMaps" : [
+ {
+ "value" : "null",
+ "text" : "N/A",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "value" : "0",
+ "text" : "ENABLED"
+ },
+ {
+ "value" : "1",
+ "text" : "ACTIVE",
+ "op" : "="
+ },
+ {
+ "op" : "=",
+ "text" : "DISABLED",
+ "value" : "2"
+ }
+ ],
+ "prefixFontSize" : "50%",
+ "height" : "95",
+ "mappingType" : 1,
+ "interval" : null
+ }
+ ],
+ "showTitle" : true,
+ "titleSize" : "h5",
+ "repeat" : null,
+ "title" : "Cluster State",
+ "collapse" : false,
+ "height" : "200",
+ "repeatRowId" : null
+ },
+ {
+ "titleSize" : "h5",
+ "repeatIteration" : null,
+ "showTitle" : true,
+ "panels" : [
+ {
+ "transform" : "timeseries_aggregations",
+ "title" : "Disks Near Full",
+ "scroll" : true,
+ "minSpan" : 1,
+ "pageSize" : null,
+ "showHeader" : true,
+ "targets" : [
+ {
+ "textEditor" : true,
+ "target" : "aliasByNode(currentAbove(transformNull(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.osd_percent_used),0),$disk_full_threshold),1,-2)",
+ "refId" : "A"
+ }
+ ],
+ "span" : 1,
+ "fontSize" : "100%",
+ "columns" : [
+ {
+ "value" : "current",
+ "text" : "Current"
+ }
+ ],
+ "sort" : {
+ "desc" : true,
+ "col" : 0
+ },
+ "type" : "table",
+ "styles" : [
+ {
+ "type" : "date",
+ "alias" : "Time",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "pattern" : "Time"
+ },
+ {
+ "colorMode" : null,
+ "thresholds" : [],
+ "type" : "hidden",
+ "alias" : "% Full",
+ "unit" : "none",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "pattern" : "Current",
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals" : 0
+ },
+ {
+ "alias" : "Host.OSD Id",
+ "type" : "number",
+ "colorMode" : null,
+ "thresholds" : [],
+ "pattern" : "Metric",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "unit" : "short",
+ "decimals" : 2,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ]
+ },
+ {
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals" : 2,
+ "unit" : "short",
+ "pattern" : "/.*/",
+ "type" : "number",
+ "alias" : "",
+ "colorMode" : null,
+ "thresholds" : []
+ }
+ ],
+ "id" : 75,
+ "links" : []
+ },
+ {
+ "type" : "table",
+ "hideTimeOverride" : true,
+ "fontSize" : "100%",
+ "scroll" : true,
+ "targets" : [
+ {
+ "hide" : false,
+ "refId" : "B",
+ "target" : "currentBelow(groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_state.*.up,-2,\"maxSeries\"),0.5)",
+ "textEditor" : true
+ }
+ ],
+ "pageSize" : 100,
+ "showHeader" : true,
+ "timeFrom" : "1m",
+ "transform" : "timeseries_aggregations",
+ "styles" : [
+ {
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "unit" : "short",
+ "pattern" : "Metric",
+ "sanitize" : false,
+ "alias" : "OSD Id",
+ "type" : "number",
+ "colorMode" : null,
+ "thresholds" : [
+ ""
+ ],
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "decimals" : 0
+ },
+ {
+ "alias" : "Status",
+ "type" : "hidden",
+ "colorMode" : "cell",
+ "thresholds" : [
+ "0"
+ ],
+ "pattern" : "Current",
+ "unit" : "short",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "decimals" : 0,
+ "colors" : [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ]
+ }
+ ],
+ "sort" : {
+ "col" : null,
+ "desc" : false
+ },
+ "id" : 71,
+ "links" : [],
+ "columns" : [
+ {
+ "text" : "Current",
+ "value" : "current"
+ }
+ ],
+ "title" : "OSD's Down",
+ "timeShift" : null,
+ "minSpan" : 1,
+ "span" : 1
+ },
+ {
+ "hideTimeOverride" : true,
+ "type" : "table",
+ "fontSize" : "100%",
+ "pageSize" : null,
+ "showHeader" : true,
+ "targets" : [
+ {
+ "textEditor" : true,
+ "target" : "currentBelow(groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_state.*.in,-2,\"minSeries\"),0.5)",
+ "refId" : "B",
+ "hide" : false
+ }
+ ],
+ "scroll" : true,
+ "transform" : "timeseries_aggregations",
+ "timeFrom" : "5m",
+ "id" : 74,
+ "links" : [],
+ "sort" : {
+ "col" : 0,
+ "desc" : true
+ },
+ "styles" : [
+ {
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "pattern" : "Time",
+ "alias" : "Time",
+ "type" : "date"
+ },
+ {
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "unit" : "none",
+ "pattern" : "Current",
+ "alias" : "",
+ "type" : "hidden",
+ "thresholds" : [],
+ "colorMode" : null,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals" : 0
+ },
+ {
+ "type" : "number",
+ "alias" : "OSD Id",
+ "thresholds" : [],
+ "colorMode" : null,
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "unit" : "short",
+ "pattern" : "Metric",
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals" : 2
+ },
+ {
+ "pattern" : "/.*/",
+ "unit" : "short",
+ "colorMode" : null,
+ "thresholds" : [],
+ "type" : "number",
+ "alias" : "",
+ "decimals" : 2,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ]
+ }
+ ],
+ "columns" : [
+ {
+ "text" : "Current",
+ "value" : "current"
+ }
+ ],
+ "span" : 1,
+ "timeShift" : null,
+ "title" : "OSDs Out",
+ "minSpan" : 1
+ },
+ {
+ "title" : "",
+ "minSpan" : 1,
+ "span" : 1,
+ "transparent" : true,
+ "mode" : "html",
+ "type" : "text",
+ "links" : [],
+ "id" : 73,
+ "content" : ""
+ },
+ {
+ "columns" : [
+ {
+ "value" : "current",
+ "text" : "Current"
+ }
+ ],
+ "links" : [],
+ "id" : 10,
+ "styles" : [
+ {
+ "pattern" : "Time",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "type" : "date"
+ },
+ {
+ "decimals" : 2,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "pattern" : "Metric",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "unit" : "short",
+ "type" : "number",
+ "alias" : "Object State",
+ "colorMode" : null,
+ "thresholds" : []
+ },
+ {
+ "pattern" : "Current",
+ "unit" : "none",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "thresholds" : [],
+ "colorMode" : null,
+ "type" : "number",
+ "alias" : "Count",
+ "decimals" : 0,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ]
+ },
+ {
+ "pattern" : "/.*/",
+ "unit" : "none",
+ "colorMode" : null,
+ "thresholds" : [],
+ "type" : "number",
+ "decimals" : 0,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ]
+ }
+ ],
+ "sort" : {
+ "col" : null,
+ "desc" : false
+ },
+ "datasource" : "Local",
+ "span" : 4,
+ "filterNull" : false,
+ "title" : "Object Summary",
+ "minSpan" : 3,
+ "fontSize" : "100%",
+ "type" : "table",
+ "transform" : "timeseries_aggregations",
+ "targets" : [
+ {
+ "target" : "alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_object), 'Total Objects')",
+ "dsType" : "influxdb",
+ "tags" : [],
+ "alias" : "Objects",
+ "refId" : "A",
+ "select" : [
+ [
+ {
+ "params" : [
+ "value"
+ ],
+ "type" : "field"
+ },
+ {
+ "type" : "mean",
+ "params" : []
+ }
+ ]
+ ],
+ "textEditor" : true,
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy" : "default",
+ "groupBy" : [
+ {
+ "type" : "time",
+ "params" : [
+ "$__interval"
+ ]
+ },
+ {
+ "type" : "fill",
+ "params" : [
+ "null"
+ ]
+ }
+ ],
+ "resultFormat" : "time_series"
+ },
+ {
+ "refId" : "B",
+ "target" : "alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_object_degraded), 'Objects degraded')",
+ "dsType" : "influxdb",
+ "tags" : [],
+ "alias" : "Objects",
+ "groupBy" : [
+ {
+ "params" : [
+ "$__interval"
+ ],
+ "type" : "time"
+ },
+ {
+ "params" : [
+ "null"
+ ],
+ "type" : "fill"
+ }
+ ],
+ "resultFormat" : "time_series",
+ "select" : [
+ [
+ {
+ "type" : "field",
+ "params" : [
+ "value"
+ ]
+ },
+ {
+ "params" : [],
+ "type" : "mean"
+ }
+ ]
+ ],
+ "textEditor" : true,
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy" : "default"
+ },
+ {
+ "dsType" : "influxdb",
+ "alias" : "Objects",
+ "tags" : [],
+ "target" : "alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_object_misplaced), 'Objects misplaced')",
+ "refId" : "C",
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy" : "default",
+ "select" : [
+ [
+ {
+ "type" : "field",
+ "params" : [
+ "value"
+ ]
+ },
+ {
+ "type" : "mean",
+ "params" : []
+ }
+ ]
+ ],
+ "textEditor" : true,
+ "groupBy" : [
+ {
+ "type" : "time",
+ "params" : [
+ "$__interval"
+ ]
+ },
+ {
+ "params" : [
+ "null"
+ ],
+ "type" : "fill"
+ }
+ ],
+ "resultFormat" : "time_series"
+ },
+ {
+ "select" : [
+ [
+ {
+ "params" : [
+ "value"
+ ],
+ "type" : "field"
+ },
+ {
+ "params" : [],
+ "type" : "mean"
+ }
+ ]
+ ],
+ "textEditor" : true,
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_object",
+ "policy" : "default",
+ "groupBy" : [
+ {
+ "params" : [
+ "$__interval"
+ ],
+ "type" : "time"
+ },
+ {
+ "params" : [
+ "null"
+ ],
+ "type" : "fill"
+ }
+ ],
+ "resultFormat" : "time_series",
+ "target" : "alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_object_unfound), 'Objects unfound')",
+ "dsType" : "influxdb",
+ "alias" : "Objects",
+ "tags" : [],
+ "refId" : "D"
+ }
+ ],
+ "pageSize" : null,
+ "showHeader" : true,
+ "scroll" : true
+ },
+ {
+ "type" : "text",
+ "content" : "",
+ "links" : [],
+ "id" : 67,
+ "mode" : "markdown",
+ "transparent" : true,
+ "minSpan" : 1,
+ "title" : "",
+ "span" : 1
+ },
+ {
+ "showHeader" : true,
+ "pageSize" : null,
+ "targets" : [
+ {
+ "refId" : "A",
+ "target" : "alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_pg), 'PGs')",
+ "dsType" : "influxdb",
+ "alias" : "PG's",
+ "tags" : [],
+ "groupBy" : [
+ {
+ "params" : [
+ "$__interval"
+ ],
+ "type" : "time"
+ },
+ {
+ "type" : "fill",
+ "params" : [
+ "null"
+ ]
+ }
+ ],
+ "resultFormat" : "time_series",
+ "select" : [
+ [
+ {
+ "params" : [
+ "value"
+ ],
+ "type" : "field"
+ },
+ {
+ "params" : [],
+ "type" : "mean"
+ }
+ ]
+ ],
+ "textEditor" : true,
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy" : "default"
+ },
+ {
+ "dsType" : "influxdb",
+ "alias" : "PG's",
+ "tags" : [],
+ "target" : "alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_pg_active), 'Active PGs')",
+ "refId" : "B",
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy" : "default",
+ "select" : [
+ [
+ {
+ "type" : "field",
+ "params" : [
+ "value"
+ ]
+ },
+ {
+ "params" : [],
+ "type" : "mean"
+ }
+ ]
+ ],
+ "textEditor" : true,
+ "groupBy" : [
+ {
+ "type" : "time",
+ "params" : [
+ "$__interval"
+ ]
+ },
+ {
+ "params" : [
+ "null"
+ ],
+ "type" : "fill"
+ }
+ ],
+ "resultFormat" : "time_series"
+ },
+ {
+ "groupBy" : [
+ {
+ "type" : "time",
+ "params" : [
+ "$__interval"
+ ]
+ },
+ {
+ "params" : [
+ "null"
+ ],
+ "type" : "fill"
+ }
+ ],
+ "resultFormat" : "time_series",
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "policy" : "default",
+ "select" : [
+ [
+ {
+ "params" : [
+ "value"
+ ],
+ "type" : "field"
+ },
+ {
+ "type" : "mean",
+ "params" : []
+ }
+ ]
+ ],
+ "textEditor" : true,
+ "refId" : "C",
+ "dsType" : "influxdb",
+ "alias" : "PG's",
+ "tags" : [],
+ "target" : "alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_pg_active_clean), 'Active+clean PGs')"
+ },
+ {
+ "policy" : "default",
+ "measurement" : "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.num_pg",
+ "textEditor" : true,
+ "select" : [
+ [
+ {
+ "type" : "field",
+ "params" : [
+ "value"
+ ]
+ },
+ {
+ "type" : "mean",
+ "params" : []
+ }
+ ]
+ ],
+ "resultFormat" : "time_series",
+ "groupBy" : [
+ {
+ "params" : [
+ "$__interval"
+ ],
+ "type" : "time"
+ },
+ {
+ "type" : "fill",
+ "params" : [
+ "null"
+ ]
+ }
+ ],
+ "alias" : "PG's",
+ "tags" : [],
+ "dsType" : "influxdb",
+ "target" : "alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_pg_peering), 'PGs peering')",
+ "refId" : "D"
+ }
+ ],
+ "scroll" : true,
+ "transform" : "timeseries_aggregations",
+ "type" : "table",
+ "fontSize" : "100%",
+ "filterNull" : false,
+ "span" : 3,
+ "title" : "PG Summary",
+ "minSpan" : 3,
+ "datasource" : "Local",
+ "id" : 13,
+ "links" : [],
+ "sort" : {
+ "desc" : false,
+ "col" : null
+ },
+ "styles" : [
+ {
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "pattern" : "Time",
+ "type" : "date"
+ },
+ {
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals" : 2,
+ "thresholds" : [],
+ "colorMode" : null,
+ "type" : "number",
+ "alias" : "PG State",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "unit" : "short",
+ "pattern" : "Metric"
+ },
+ {
+ "colorMode" : null,
+ "thresholds" : [],
+ "type" : "number",
+ "alias" : "Count",
+ "pattern" : "Current",
+ "unit" : "none",
+ "dateFormat" : "YYYY-MM-DD HH:mm:ss",
+ "decimals" : 0,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ]
+ },
+ {
+ "decimals" : 0,
+ "type" : "number",
+ "thresholds" : [],
+ "colorMode" : null,
+ "colors" : [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "pattern" : "/.*/",
+ "unit" : "none"
+ }
+ ],
+ "columns" : [
+ {
+ "text" : "Current",
+ "value" : "current"
+ }
+ ]
+ }
+ ],
+ "title" : "Storage Information",
+ "collapse" : true,
+ "repeatRowId" : null,
+ "height" : 250,
+ "repeat" : null
+ }
+ ],
+ "hideControls" : true,
+ "timezone" : "browser",
+ "refresh" : "10s",
+ "title" : "Ceph Health",
+ "schemaVersion" : 14,
+ "graphTooltip" : 0,
+ "version" : 41,
+ "editable" : false,
+ "timepicker" : {
+ "time_options" : [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ],
+ "refresh_intervals" : [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ]
+ }
+ },
+ "meta" : {
+ "canEdit" : true,
+ "canSave" : true,
+ "slug" : "ceph-health",
+ "updatedBy" : "admin",
+ "canStar" : true,
+ "createdBy" : "admin",
+ "type" : "db",
+ "updated" : "2017-08-19T21:14:18Z",
+ "expires" : "0001-01-01T00:00:00Z",
+ "created" : "2017-08-08T03:07:37Z",
+ "version" : 41
+ }
+}
--- /dev/null
+{
+ "dashboard": {
+ "annotations": {
+ "list": []
+ },
+ "editable": false,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": true,
+ "id": 67,
+ "links": [
+ {
+ "asDropdown": true,
+ "icon": "external link",
+ "tags": [
+ "overview"
+ ],
+ "title": "Shortcuts",
+ "type": "dashboards"
+ }
+ ],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": "220px",
+ "panels": [
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "Local",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 11,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "keepLastValue(consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd), \"max\"))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "OSDs",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "Local",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 12,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "keepLastValue(consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd_up),\"max\"))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "OSDs UP",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "avg"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": true,
+ "colorValue": false,
+ "colors": [
+ "rgba(251,251,251,0.97)",
+ "rgba(255,165,0, 1)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "datasource": "Local",
+ "decimals": 0,
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "id": 16,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "hide": true,
+ "refId": "A",
+ "target": "keepLastValue(consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd_up),\"max\"))",
+ "textEditor": true
+ },
+ {
+ "hide": true,
+ "refId": "B",
+ "target": "keepLastValue(consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd), \"max\"))",
+ "textEditor": true
+ },
+ {
+ "refId": "C",
+ "target": "diffSeries(#B,#A)",
+ "targetFull": "diffSeries(keepLastValue(consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd), \"max\")),keepLastValue(consolidateBy(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd_up),\"max\")))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "1,3",
+ "title": "OSDs DOWN",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "aliasColors": {},
+ "cacheTimeout": null,
+ "combine": {
+ "label": "Others",
+ "threshold": 0
+ },
+ "datasource": "Local",
+ "description": "The pie chart shows the varios disk sizes used within the cluster",
+ "fontSize": "80%",
+ "format": "none",
+ "height": "220",
+ "id": 13,
+ "interval": null,
+ "legend": {
+ "percentage": false,
+ "show": true,
+ "sortDesc": true,
+ "values": true
+ },
+ "legendType": "Right side",
+ "links": [],
+ "maxDataPoints": "1",
+ "minSpan": 3,
+ "nullPointMode": "connected",
+ "pieType": "pie",
+ "span": 3,
+ "strokeWidth": "1",
+ "targets": [
+ {
+ "hide": true,
+ "refId": "A",
+ "target": "keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.stat_bytes, 6)",
+ "textEditor": true
+ },
+ {
+ "hide": true,
+ "refId": "B",
+ "target": "alias(currentBelow(#A,1099511627776),\"<1TB\")",
+ "targetFull": "alias(currentBelow(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.stat_bytes, 6),1099511627776),\"<1TB\")",
+ "textEditor": true
+ },
+ {
+ "hide": true,
+ "refId": "C",
+ "target": "alias(currentBelow(currentAbove(#A,1099511627776),2199023255552),\"2TB\")",
+ "targetFull": "alias(currentBelow(currentAbove(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.stat_bytes, 6),1099511627776),2199023255552),\"2TB\")",
+ "textEditor": true
+ },
+ {
+ "hide": true,
+ "refId": "D",
+ "target": "alias(currentBelow(currentAbove(#A,2199023255552),4398046511104),\"4TB\")",
+ "targetFull": "alias(currentBelow(currentAbove(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.stat_bytes, 6),2199023255552),4398046511104),\"4TB\")",
+ "textEditor": true
+ },
+ {
+ "hide": true,
+ "refId": "E",
+ "target": "alias(currentBelow(currentAbove(#A,4398046511104),6597069766656),\"6TB\")",
+ "targetFull": "alias(currentBelow(currentAbove(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.stat_bytes, 6),4398046511104),6597069766656),\"6TB\")",
+ "textEditor": true
+ },
+ {
+ "hide": true,
+ "refId": "F",
+ "target": "alias(currentBelow(currentAbove(#A,6597069766656),8796093022208),\"8TB\")",
+ "targetFull": "alias(currentBelow(currentAbove(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.stat_bytes, 6),6597069766656),8796093022208),\"8TB\")",
+ "textEditor": true
+ },
+ {
+ "hide": true,
+ "refId": "G",
+ "target": "alias(currentBelow(currentAbove(#A,8796093022208),10995116277760),\"10TB\")",
+ "targetFull": "alias(currentBelow(currentAbove(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.stat_bytes, 6),8796093022208),10995116277760),\"10TB\")",
+ "textEditor": true
+ },
+ {
+ "hide": true,
+ "refId": "H",
+ "target": "alias(currentBelow(currentAbove(#A,10995116277760),13194139533312),\"12TB\")",
+ "targetFull": "alias(currentBelow(currentAbove(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.stat_bytes, 6),10995116277760),13194139533312),\"12TB\")",
+ "textEditor": true
+ },
+ {
+ "refId": "I",
+ "target": "alias(countSeries(#B), \"<1TB\")",
+ "targetFull": "alias(countSeries(alias(currentBelow(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.stat_bytes, 6),1099511627776),\"<1TB\")), \"<1TB\")",
+ "textEditor": true
+ },
+ {
+ "refId": "J",
+ "target": "alias(countSeries(#C), \"2TB\")",
+ "targetFull": "alias(countSeries(alias(currentBelow(currentAbove(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.stat_bytes, 6),1099511627776),2199023255552),\"2TB\")), \"2TB\")",
+ "textEditor": true
+ },
+ {
+ "refId": "K",
+ "target": "alias(countSeries(#D), \"4TB\")",
+ "targetFull": "alias(countSeries(alias(currentBelow(currentAbove(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.stat_bytes, 6),2199023255552),4398046511104),\"4TB\")), \"4TB\")",
+ "textEditor": true
+ },
+ {
+ "refId": "L",
+ "target": "alias(countSeries(#E), \"6TB\")",
+ "targetFull": "alias(countSeries(alias(currentBelow(currentAbove(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.stat_bytes, 6),4398046511104),6597069766656),\"6TB\")), \"6TB\")",
+ "textEditor": true
+ },
+ {
+ "refId": "M",
+ "target": "alias(countSeries(#F), \"8TB\")",
+ "targetFull": "alias(countSeries(alias(currentBelow(currentAbove(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.stat_bytes, 6),6597069766656),8796093022208),\"8TB\")), \"8TB\")",
+ "textEditor": true
+ },
+ {
+ "refId": "N",
+ "target": "alias(countSeries(#G), \"10TB\")",
+ "targetFull": "alias(countSeries(alias(currentBelow(currentAbove(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.stat_bytes, 6),8796093022208),10995116277760),\"10TB\")), \"10TB\")",
+ "textEditor": true
+ },
+ {
+ "refId": "O",
+ "target": "alias(countSeries(#H), \"12TB\")",
+ "targetFull": "alias(countSeries(alias(currentBelow(currentAbove(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.stat_bytes, 6),10995116277760),13194139533312),\"12TB\")), \"12TB\")",
+ "textEditor": true
+ }
+ ],
+ "title": "OSD Disk Size Summary",
+ "type": "grafana-piechart-panel",
+ "valueName": "current"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "fontSize": "100%",
+ "id": 18,
+ "links": [],
+ "maxDataPoints": "1",
+ "minSpan": 2,
+ "pageSize": 10,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": false
+ },
+ "span": 2,
+ "styles": [
+ {
+ "alias": "Time",
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "alias": "Disk Size",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 0,
+ "pattern": "Current",
+ "thresholds": [],
+ "type": "number",
+ "unit": "decbytes"
+ },
+ {
+ "alias": "Hostname.OSD Id",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Metric",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ },
+ {
+ "alias": "",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 2,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(keepLastValue(maximumAbove(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.$osd_id.stat_bytes,0)),1,-2)",
+ "textEditor": true
+ }
+ ],
+ "title": "OSD Size",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "aliasColors": {
+ "Non-Encrypted": "#E5AC0E"
+ },
+ "cacheTimeout": null,
+ "combine": {
+ "label": "Others",
+ "threshold": 0
+ },
+ "datasource": null,
+ "fontSize": "80%",
+ "format": "none",
+ "height": "200px",
+ "id": 19,
+ "interval": null,
+ "legend": {
+ "percentage": false,
+ "show": true,
+ "values": true
+ },
+ "legendType": "Under graph",
+ "links": [],
+ "maxDataPoints": "1",
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "pieType": "pie",
+ "span": 2,
+ "strokeWidth": 1,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(countSeries(maximumAbove(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.encrypted),0.5)),\"Encrypted\")",
+ "textEditor": true
+ },
+ {
+ "refId": "B",
+ "target": "alias(countSeries(maximumBelow(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.encrypted),0.5)),\"Non-Encrypted\")",
+ "textEditor": true
+ }
+ ],
+ "title": "OSD Encryption Summary",
+ "type": "grafana-piechart-panel",
+ "valueName": "current"
+ },
+ {
+ "aliasColors": {
+ "Non-Encrypted": "#E5AC0E"
+ },
+ "cacheTimeout": null,
+ "combine": {
+ "label": "Others",
+ "threshold": 0
+ },
+ "datasource": null,
+ "fontSize": "80%",
+ "format": "none",
+ "height": "200px",
+ "id": 20,
+ "interval": null,
+ "legend": {
+ "percentage": false,
+ "show": true,
+ "values": true
+ },
+ "legendType": "Under graph",
+ "links": [],
+ "maxDataPoints": "1",
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "pieType": "pie",
+ "span": 2,
+ "strokeWidth": 1,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(countSeries(maximumAbove(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.osd_type),0.5)),\"Bluestore\")",
+ "textEditor": true
+ },
+ {
+ "refId": "B",
+ "target": "alias(countSeries(maximumBelow(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.osd_type),0.5)),\"Filestore\")",
+ "textEditor": true
+ }
+ ],
+ "title": "Summary of OSD Types",
+ "type": "grafana-piechart-panel",
+ "valueName": "current"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "OSD Summary",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": "",
+ "panels": [
+ {
+ "content": "<h1>Ceph Filestore I/O Process</h1>\n<p style=\"text-align: justify;\">\nA write request is issued to a 'primary' OSD and committed to a journal using direct-io (<i><b>apply</b></i>). Once this write is complete, the data is persisted to HDD by a second 'buffered' write operation (<i><b>commit</b></i>). The commit operation is basically a measure of time taken to perform a <i>syncfs</i> call to flush dirty pages to disk, and is therefore <b>not</b> a time associated with any specific client initiated operation.<p> The tables on the right show the top 10 OSDs with the highest latencies.\n",
+ "height": "300",
+ "id": 10,
+ "links": [],
+ "minSpan": 4,
+ "mode": "html",
+ "span": 4,
+ "title": "",
+ "type": "text"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "description": "Time spent in the queue for the journal. Excessive times here may indicate OSD tthrottling is happening. In this scenario you should review the OSD specific settings in \"ceph.conf\"; filestore_queue_max_ops or filestore_queue_max_bytes",
+ "fontSize": "100%",
+ "height": "300",
+ "id": 3,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": 5,
+ "scroll": false,
+ "showHeader": true,
+ "sort": {
+ "col": 1,
+ "desc": true
+ },
+ "span": 2,
+ "styles": [
+ {
+ "alias": "Time",
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "alias": "Journal Queue Time",
+ "colorMode": "row",
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Current",
+ "thresholds": [
+ ".001",
+ ".003"
+ ],
+ "type": "number",
+ "unit": "s"
+ },
+ {
+ "alias": "OSD Id",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Metric",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ },
+ {
+ "alias": "",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 2,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(limit(maximumAbove(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.queue_transaction_latency_avg,0),$max_devices),-2)",
+ "textEditor": true
+ }
+ ],
+ "title": "",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "description": "Time taken for the write request to be safely committed to the journal device",
+ "fontSize": "100%",
+ "height": "300",
+ "id": 4,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": 5,
+ "scroll": false,
+ "showHeader": true,
+ "sort": {
+ "col": 1,
+ "desc": true
+ },
+ "span": 2,
+ "styles": [
+ {
+ "alias": "Time",
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "alias": "Journal Latency",
+ "colorMode": "row",
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Current",
+ "thresholds": [
+ "0.01",
+ "0.1"
+ ],
+ "type": "number",
+ "unit": "s"
+ },
+ {
+ "alias": "OSD Id",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Metric",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ },
+ {
+ "alias": "",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 2,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(limit(maximumAbove(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.journal_latency,0),$max_devices),-2)",
+ "textEditor": true
+ }
+ ],
+ "title": "",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "description": "Apply latency covers the time taken to commit to the journal and complete the transaction",
+ "fontSize": "100%",
+ "height": "300",
+ "id": 5,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": 5,
+ "scroll": false,
+ "showHeader": true,
+ "sort": {
+ "col": 1,
+ "desc": true
+ },
+ "span": 2,
+ "styles": [
+ {
+ "alias": "Time",
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "alias": "Apply Latency",
+ "colorMode": "row",
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Current",
+ "thresholds": [
+ "100",
+ "500"
+ ],
+ "type": "number",
+ "unit": "s"
+ },
+ {
+ "alias": "OSD Id",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Metric",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ },
+ {
+ "alias": "",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 2,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(limit(maximumAbove(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.apply_latency,0),$max_devices),-2)",
+ "textEditor": true
+ }
+ ],
+ "title": "",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "description": "Commit latency is the time taken for writes to be flushed to disk as part of async kernel activity",
+ "fontSize": "100%",
+ "height": "300",
+ "id": 6,
+ "links": [],
+ "minSpan": 2,
+ "pageSize": 5,
+ "scroll": false,
+ "showHeader": true,
+ "sort": {
+ "col": 1,
+ "desc": true
+ },
+ "span": 2,
+ "styles": [
+ {
+ "alias": "Time",
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "alias": "Commit Latency",
+ "colorMode": "row",
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Current",
+ "thresholds": [
+ "1",
+ "3"
+ ],
+ "type": "number",
+ "unit": "s"
+ },
+ {
+ "alias": "OSD Id",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Metric",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ },
+ {
+ "alias": "",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 2,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(limit(maximumAbove(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.commitcycle_latency,0),$max_devices),-2)",
+ "textEditor": true
+ }
+ ],
+ "title": "",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "aliasColors": {
+ "95%ile Commit Latency": "#447EBC",
+ "Apply Latency Max": "#890F02"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "description": "Shows the latency for a given OSD, allowing you to compare a specific OSD against the $percentile%ile graph. Note that when the \"OSD Id\" pull-down shows **ALL**, only the **first** OSD is shown to prevent the graph from being unreadable!",
+ "fill": 0,
+ "height": "300px",
+ "id": 1,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "maxDataPoints": "",
+ "minSpan": 6,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [
+ {
+ "alias": "Apply Latency Max",
+ "fill": 0
+ },
+ {
+ "alias": "95%ile Apply Latency",
+ "fill": 2
+ }
+ ],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(limit(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.$osd_id.queue_transaction_latency_avg,1),\"Journal queue avg\")",
+ "textEditor": true
+ },
+ {
+ "refId": "B",
+ "target": "alias(limit(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.$osd_id.journal_latency,1),\"Journal latency avg\")",
+ "textEditor": true
+ },
+ {
+ "refId": "C",
+ "target": "alias(limit(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.$osd_id.apply_latency,1), \"Apply latency avg\")",
+ "textEditor": true
+ },
+ {
+ "refId": "D",
+ "target": "alias(limit(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.$osd_id.commitcycle_latency,1),\"Commit latency avg\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Latency for OSD Id - '$osd_id'",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "s",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "height": "300px",
+ "id": 9,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(percentileOfSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.queue_transaction_latency_avg,$percentile), \"journal Queue time\")",
+ "textEditor": true
+ },
+ {
+ "refId": "B",
+ "target": "alias(percentileOfSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.journal_latency,$percentile), \"journal Latency\")",
+ "textEditor": true
+ },
+ {
+ "refId": "C",
+ "target": "alias(percentileOfSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.apply_latency,$percentile), \"apply Latency\")",
+ "textEditor": true
+ },
+ {
+ "refId": "D",
+ "target": "alias(percentileOfSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*.commitcycle_latency,$percentile), \"commit/flush Latency\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "IO Summary across all OSD's @ $percentile%ile",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "s",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Filestore OSD Latencies",
+ "titleSize": "h5"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [
+ "overview"
+ ],
+ "templating": {
+ "list": [
+ {
+ "allValue": null,
+ "current": {
+ "text": "storage.lab",
+ "value": "storage.lab"
+ },
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "domain",
+ "options": [
+ {
+ "selected": true,
+ "text": "storage.lab",
+ "value": "storage.lab"
+ }
+ ],
+ "query": "storage.lab",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "ceph",
+ "value": "ceph"
+ },
+ "datasource": "Local",
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "cluster_name",
+ "options": [],
+ "query": "collectd.*.$domain.cephmetrics.gauge.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "text": "95",
+ "value": "95"
+ },
+ "hide": 0,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "percentile",
+ "options": [
+ {
+ "selected": true,
+ "text": "95",
+ "value": "95"
+ },
+ {
+ "selected": false,
+ "text": "96",
+ "value": "96"
+ },
+ {
+ "selected": false,
+ "text": "97",
+ "value": "97"
+ },
+ {
+ "selected": false,
+ "text": "98",
+ "value": "98"
+ },
+ {
+ "selected": false,
+ "text": "99",
+ "value": "99"
+ }
+ ],
+ "query": "95,96,97,98,99",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "text": "10",
+ "value": "10"
+ },
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "max_devices",
+ "options": [
+ {
+ "selected": true,
+ "text": "10",
+ "value": "10"
+ }
+ ],
+ "query": "10",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "tags": [],
+ "text": "All",
+ "value": "$__all"
+ },
+ "datasource": "Local",
+ "hide": 0,
+ "includeAll": true,
+ "label": "OSD Id",
+ "multi": false,
+ "name": "osd_id",
+ "options": [],
+ "query": "collectd.*.$domain.cephmetrics.gauge.$cluster_name.osd.*",
+ "refresh": 1,
+ "regex": "/^\\d+$/",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ }
+ ]
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "Ceph OSD Information",
+ "version": 3
+ },
+ "meta": {
+ "canEdit": true,
+ "canSave": true,
+ "canStar": true,
+ "created": "2017-08-02T01:47:18Z",
+ "createdBy": "admin@localhost",
+ "expires": "0001-01-01T00:00:00Z",
+ "slug": "ceph-osd-information",
+ "type": "db",
+ "updated": "2017-08-03T04:50:23Z",
+ "updatedBy": "admin@localhost",
+ "version": 3
+ }
+}
\ No newline at end of file
--- /dev/null
+{
+ "dashboard": {
+ "annotations": {
+ "list": []
+ },
+ "editable": true,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": false,
+ "id": 60,
+ "links": [],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": "400px",
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 5,
+ "id": 1,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 2,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.op_per_sec,-2,\"maxSeries\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Client IOPS by Pool",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 5,
+ "id": 2,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 2,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.bytes_sec,-2,\"maxSeries\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Throughput by Pool",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 3,
+ "id": 52,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.*.recovering_bytes_per_sec,-2,\"maxSeries\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Recovery Workload by Pool",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Pool Overview",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "fontSize": "100%",
+ "id": 3,
+ "links": [],
+ "minSpan": 6,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 1,
+ "desc": true
+ },
+ "span": 6,
+ "styles": [
+ {
+ "alias": "Time",
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "alias": "Pool Name",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Metric",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ },
+ {
+ "alias": "IOPS",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 0,
+ "pattern": "Current",
+ "thresholds": [],
+ "type": "number",
+ "unit": "none"
+ },
+ {
+ "alias": "",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 2,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "limit(groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.*.op_per_sec,-2,\"maxSeries\"),5)",
+ "textEditor": true
+ }
+ ],
+ "title": "Top 5 Pools by Client IOPS",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "fontSize": "100%",
+ "id": 4,
+ "links": [],
+ "minSpan": 6,
+ "pageSize": null,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 1,
+ "desc": true
+ },
+ "span": 6,
+ "styles": [
+ {
+ "alias": "Time",
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "alias": "Pool Name",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Metric",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ },
+ {
+ "alias": "Throughput",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Current",
+ "thresholds": [],
+ "type": "number",
+ "unit": "bytes"
+ },
+ {
+ "alias": "",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 2,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "bytes"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "limit(groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.*.bytes_sec,-2,\"maxSeries\"),5)",
+ "textEditor": true
+ }
+ ],
+ "title": "Top 5 Pools by Throughput",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Top 5",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 5,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "_rgw_root",
+ "value": "_rgw_root"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 7,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "_rgw_root",
+ "value": "_rgw_root"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client Throughput",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": "pool_name",
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Pool '$pool_name' Performance Details",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 53,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_buckets_data",
+ "value": "default_rgw_buckets_data"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 54,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_buckets_data",
+ "value": "default_rgw_buckets_data"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client Throughput",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": 1501620381314,
+ "repeatRowId": 3,
+ "showTitle": true,
+ "title": "Pool '$pool_name' Performance Details",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 55,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_buckets_index",
+ "value": "default_rgw_buckets_index"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 56,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_buckets_index",
+ "value": "default_rgw_buckets_index"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client Throughput",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": 1501620381314,
+ "repeatRowId": 3,
+ "showTitle": true,
+ "title": "Pool '$pool_name' Performance Details",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 57,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_control",
+ "value": "default_rgw_control"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 58,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_control",
+ "value": "default_rgw_control"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client Throughput",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": 1501620381314,
+ "repeatRowId": 3,
+ "showTitle": true,
+ "title": "Pool '$pool_name' Performance Details",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 59,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_data_root",
+ "value": "default_rgw_data_root"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 60,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_data_root",
+ "value": "default_rgw_data_root"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client Throughput",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": 1501620381314,
+ "repeatRowId": 3,
+ "showTitle": true,
+ "title": "Pool '$pool_name' Performance Details",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 61,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_gc",
+ "value": "default_rgw_gc"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 62,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_gc",
+ "value": "default_rgw_gc"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client Throughput",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": 1501620381314,
+ "repeatRowId": 3,
+ "showTitle": true,
+ "title": "Pool '$pool_name' Performance Details",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 63,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_log",
+ "value": "default_rgw_log"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 64,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_log",
+ "value": "default_rgw_log"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client Throughput",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": 1501620381314,
+ "repeatRowId": 3,
+ "showTitle": true,
+ "title": "Pool '$pool_name' Performance Details",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 65,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_meta",
+ "value": "default_rgw_meta"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 66,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_meta",
+ "value": "default_rgw_meta"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client Throughput",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": 1501620381314,
+ "repeatRowId": 3,
+ "showTitle": true,
+ "title": "Pool '$pool_name' Performance Details",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 67,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_users_keys",
+ "value": "default_rgw_users_keys"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 68,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_users_keys",
+ "value": "default_rgw_users_keys"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client Throughput",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": 1501620381314,
+ "repeatRowId": 3,
+ "showTitle": true,
+ "title": "Pool '$pool_name' Performance Details",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 69,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_users_swift",
+ "value": "default_rgw_users_swift"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 70,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_users_swift",
+ "value": "default_rgw_users_swift"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client Throughput",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": 1501620381314,
+ "repeatRowId": 3,
+ "showTitle": true,
+ "title": "Pool '$pool_name' Performance Details",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 71,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_users_uid",
+ "value": "default_rgw_users_uid"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 72,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "default_rgw_users_uid",
+ "value": "default_rgw_users_uid"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client Throughput",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": 1501620381314,
+ "repeatRowId": 3,
+ "showTitle": true,
+ "title": "Pool '$pool_name' Performance Details",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 73,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "rbd",
+ "value": "rbd"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "read_op_per_sec": "#3F6833",
+ "write_op_per_sec": "#E5AC0E"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 74,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "pool_name": {
+ "selected": false,
+ "text": "rbd",
+ "value": "rbd"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec), -1)"
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec), -1)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Pool '$pool_name' Client Throughput",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": 1501620381314,
+ "repeatRowId": 3,
+ "showTitle": true,
+ "title": "Pool '$pool_name' Performance Details",
+ "titleSize": "h5"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [],
+ "templating": {
+ "list": [
+ {
+ "allValue": null,
+ "current": {
+ "text": "ceph",
+ "value": "ceph"
+ },
+ "datasource": "Local",
+ "hide": 0,
+ "includeAll": false,
+ "label": "Cluster Name",
+ "multi": false,
+ "name": "cluster_name",
+ "options": [],
+ "query": "collectd.*.$domain.cephmetrics.gauge.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "storage.lab",
+ "value": "storage.lab"
+ },
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "domain",
+ "options": [
+ {
+ "selected": true,
+ "text": "storage.lab",
+ "value": "storage.lab"
+ }
+ ],
+ "query": "storage.lab",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "All",
+ "value": "$__all"
+ },
+ "datasource": "Local",
+ "hide": 0,
+ "includeAll": true,
+ "label": "Pool Name",
+ "multi": true,
+ "name": "pool_name",
+ "options": [],
+ "query": "collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ }
+ ]
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "Ceph Pools",
+ "version": 0
+ },
+ "meta": {
+ "canEdit": true,
+ "canSave": true,
+ "canStar": true,
+ "created": "2017-08-01T20:47:52Z",
+ "createdBy": "admin@localhost",
+ "expires": "0001-01-01T00:00:00Z",
+ "slug": "ceph-pools",
+ "type": "db",
+ "updated": "2017-08-01T20:47:52Z",
+ "updatedBy": "admin@localhost",
+ "version": 0
+ }
+}
\ No newline at end of file
--- /dev/null
+{
+ "dashboard": {
+ "annotations": {
+ "list": []
+ },
+ "editable": true,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": false,
+ "id": 18,
+ "links": [
+ {
+ "asDropdown": true,
+ "icon": "external link",
+ "includeVars": true,
+ "keepTime": true,
+ "tags": [
+ "overview"
+ ],
+ "targetBlank": true,
+ "title": "Shortcuts",
+ "type": "dashboards"
+ }
+ ],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": 267,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "height": "250",
+ "id": 35,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "sumSeries(collectd.*.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_avgcount)",
+ "textEditor": true
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "sumSeries(collectd.*.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_sum)",
+ "textEditor": true
+ },
+ {
+ "refId": "C",
+ "target": "alias(divideSeries(#B, #A),\"GET\")",
+ "targetFull": "alias(divideSeries(sumSeries(collectd.*.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_sum), sumSeries(collectd.*.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_avgcount)),\"GET\")",
+ "textEditor": true
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "sumSeries(collectd.*.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_avgcount)",
+ "textEditor": true
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "E",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "sumSeries(collectd.*.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_sum)",
+ "textEditor": true
+ },
+ {
+ "refId": "F",
+ "target": "alias(divideSeries(#E,#D), \"PUT\")",
+ "targetFull": "alias(divideSeries(sumSeries(collectd.*.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_sum),sumSeries(collectd.*.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_avgcount)), \"PUT\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Average Request Latency - All RADOS Gateways",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "s",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(50, 172, 45, 0.97)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(245, 54, 54, 0.9)"
+ ],
+ "datasource": null,
+ "decimals": 0,
+ "description": "CPU Busy at $percentile%ile across all radosgw hosts",
+ "format": "short",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "250",
+ "id": 38,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": "",
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": " %",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": true
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "percentileOfSeries(groupByNode(collectd.$rgw_servers.$domain.cpu.percent.{system,user,wait,interrupt},1,\"sumSeries\"),$percentile)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "70,90",
+ "title": "RGW Hosts CPU Busy",
+ "type": "singlestat",
+ "valueFontSize": "100%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "aliasColors": {
+ "Failed HTTP Requests": "#0A437C"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "description": "Shows the number of failed/aborted requests across all rados gateways during the last 10secs",
+ "fill": 3,
+ "height": "250",
+ "id": 152,
+ "legend": {
+ "alignAsTable": false,
+ "avg": false,
+ "current": false,
+ "hideEmpty": false,
+ "hideZero": false,
+ "max": false,
+ "min": false,
+ "rightSide": false,
+ "show": false,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 2,
+ "links": [],
+ "minSpan": 2,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 2,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.$rgw_servers.$domain.cephmetrics.derive.$cluster_name.rgw.failed_req, 1, \"maxSeries\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Failed HTTP Requests",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": false,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "none",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": null,
+ "decimals": 0,
+ "description": "",
+ "format": "short",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "250",
+ "id": 45,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": true
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "sumSeries(collectd.*.$domain.cephmetrics.derive.$cluster_name.rgw.qlen)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "Request Queue Length",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "height": "290",
+ "id": 34,
+ "legend": {
+ "alignAsTable": false,
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "rightSide": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "C",
+ "target": "groupByNode(collectd.*.$domain.cephmetrics.derive.$cluster_name.rgw.{get,put}, 1, \"sumSeries\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Total Requests/sec - All RADOS Gateways",
+ "tooltip": {
+ "shared": true,
+ "sort": 1,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "description": "Total of GET/PUT HTTP traffic through all radosgw hosts",
+ "fill": 1,
+ "height": "290",
+ "id": 39,
+ "legend": {
+ "alignAsTable": false,
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "rightSide": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "hide": false,
+ "refId": "C",
+ "target": "groupByNode(collectd.*.$domain.cephmetrics.derive.$cluster_name.rgw.{get_b,put_b}, 1, \"sumSeries\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Total Request Size - All RADOS Gateways",
+ "tooltip": {
+ "shared": true,
+ "sort": 1,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "RadosGW Overview - All Gateways",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": "300",
+ "panels": [
+ {
+ "content": "",
+ "height": "150",
+ "id": 50,
+ "links": [],
+ "minSpan": 1,
+ "mode": "markdown",
+ "scopedVars": {
+ "rgw_servers": {
+ "selected": true,
+ "text": "obj-rgw-1",
+ "value": "obj-rgw-1"
+ }
+ },
+ "span": 1,
+ "title": "",
+ "transparent": true,
+ "type": "text"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": null,
+ "decimals": 0,
+ "format": "short",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "180",
+ "id": 43,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": 100,
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": " %",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "scopedVars": {
+ "rgw_servers": {
+ "selected": true,
+ "text": "obj-rgw-1",
+ "value": "obj-rgw-1"
+ }
+ },
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": true
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "sumSeries(collectd.$rgw_servers.$domain.cpu.percent.{user,system,wait,steal,softirq,interrupt})",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "CPU Utilization",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": null,
+ "decimals": 0,
+ "description": "RAM Utilization on $rgw_servers - including a usage history covering the 12 hours",
+ "format": "short",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "180",
+ "hideTimeOverride": true,
+ "id": 46,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": "",
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": " %",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "scopedVars": {
+ "rgw_servers": {
+ "selected": true,
+ "text": "obj-rgw-1",
+ "value": "obj-rgw-1"
+ }
+ },
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": true
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "collectd.$rgw_servers.$domain.memory.percent.used",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "timeFrom": "12h",
+ "timeShift": null,
+ "title": "RAM Utilization",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "description": "Shows the total network load on the rados gw host",
+ "fill": 1,
+ "height": "180",
+ "id": 150,
+ "legend": {
+ "alignAsTable": false,
+ "avg": false,
+ "current": true,
+ "max": false,
+ "min": false,
+ "rightSide": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 3,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "rgw_servers": {
+ "selected": true,
+ "text": "obj-rgw-1",
+ "value": "obj-rgw-1"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 3,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(sumSeries(consolidateBy(collectd.$rgw_servers.$domain.interface.{en,eth,bond}*.if_octets.rx, \"sum\")),-1)",
+ "textEditor": true
+ },
+ {
+ "refId": "B",
+ "target": "aliasByNode(sumSeries(consolidateBy(collectd.$rgw_servers.$domain.interface.{en,eth,bond}*.if_octets.tx, \"sum\")),-1)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Network Load",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": false,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "Failed HTTP Requests": "#0A437C"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "description": "Shows the number of failed/aborted requests on this rados gateway during the last 10secs",
+ "fill": 3,
+ "height": "180",
+ "id": 151,
+ "legend": {
+ "alignAsTable": false,
+ "avg": false,
+ "current": true,
+ "hideEmpty": false,
+ "hideZero": false,
+ "max": false,
+ "min": false,
+ "rightSide": false,
+ "show": true,
+ "total": false,
+ "values": true
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 3,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "rgw_servers": {
+ "selected": true,
+ "text": "obj-rgw-1",
+ "value": "obj-rgw-1"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 3,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(collectd.$rgw_servers.$domain.cephmetrics.derive.$cluster_name.rgw.failed_req, \"Failed HTTP Requests\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Failed HTTP Requests",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": false,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "none",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": false
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 25,
+ "legend": {
+ "alignAsTable": false,
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "rightSide": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 4,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "rgw_servers": {
+ "selected": true,
+ "text": "obj-rgw-1",
+ "value": "obj-rgw-1"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.get",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.derive.ceph.rgw.get$/ WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$rgw_servers.$domain.cephmetrics.derive.$cluster_name.rgw.get, 'GET')",
+ "textEditor": true
+ },
+ {
+ "alias": "PUT",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.get",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.derive.ceph.rgw.put$/ WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$rgw_servers.$domain.cephmetrics.derive.$cluster_name.rgw.put, 'PUT')",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Requests",
+ "tooltip": {
+ "shared": true,
+ "sort": 1,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 19,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 4,
+ "nullPointMode": "null as zero",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "rgw_servers": {
+ "selected": true,
+ "text": "obj-rgw-1",
+ "value": "obj-rgw-1"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_servers.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_avgcount",
+ "textEditor": true
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_servers.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_sum",
+ "textEditor": true
+ },
+ {
+ "refId": "C",
+ "target": "alias(divideSeries(#B, #A),\"GET\")",
+ "targetFull": "alias(divideSeries(collectd.$rgw_servers.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_sum, collectd.$rgw_servers.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_avgcount),\"GET\")",
+ "textEditor": true
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "D",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_servers.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_avgcount"
+ },
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$interval"
+ ],
+ "type": "time"
+ }
+ ],
+ "hide": true,
+ "measurement": "collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.rgw.get_initial_lat",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.gauge.$cluster_name.rgw.get_initial_lat/ WHERE $timeFilter GROUP BY time($interval)",
+ "rawQuery": true,
+ "refId": "E",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "collectd.$rgw_servers.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_sum"
+ },
+ {
+ "refId": "F",
+ "target": "alias(divideSeries(#E,#D), \"PUT\")",
+ "targetFull": "alias(divideSeries(collectd.$rgw_servers.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_sum,collectd.$rgw_servers.$domain.cephmetrics.derive.$cluster_name.rgw.put_initial_lat_avgcount), \"PUT\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Request Latency",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "s",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 40,
+ "legend": {
+ "alignAsTable": false,
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "rightSide": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 4,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "scopedVars": {
+ "rgw_servers": {
+ "selected": true,
+ "text": "obj-rgw-1",
+ "value": "obj-rgw-1"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "alias": "GET",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.get",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.derive.ceph.rgw.get$/ WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": true,
+ "refId": "A",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$rgw_servers.$domain.cephmetrics.derive.$cluster_name.rgw.get_b, 'GET')",
+ "textEditor": true
+ },
+ {
+ "alias": "PUT",
+ "dsType": "influxdb",
+ "groupBy": [
+ {
+ "params": [
+ "$__interval"
+ ],
+ "type": "time"
+ },
+ {
+ "params": [
+ "null"
+ ],
+ "type": "fill"
+ }
+ ],
+ "measurement": "collectd.obj-rgw-1.storage.lab.cephmetrics.derive.ceph.rgw.get",
+ "policy": "default",
+ "query": "SELECT mean(\"value\") FROM /collectd.$rgw_name.cephmetrics.derive.ceph.rgw.put$/ WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+ "rawQuery": true,
+ "refId": "B",
+ "resultFormat": "time_series",
+ "select": [
+ [
+ {
+ "params": [
+ "value"
+ ],
+ "type": "field"
+ },
+ {
+ "params": [],
+ "type": "mean"
+ }
+ ]
+ ],
+ "tags": [],
+ "target": "alias(collectd.$rgw_servers.$domain.cephmetrics.derive.$cluster_name.rgw.put_b, 'PUT')",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "HTTP GET/PUT Request Sizes",
+ "tooltip": {
+ "shared": true,
+ "sort": 1,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": "rgw_servers",
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "RGW Host : $rgw_servers",
+ "titleSize": "h5"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [
+ "overview"
+ ],
+ "templating": {
+ "list": [
+ {
+ "allValue": null,
+ "current": {
+ "text": "ceph",
+ "value": "ceph"
+ },
+ "datasource": "Local",
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "cluster_name",
+ "options": [],
+ "query": "collectd.*.$domain.cephmetrics.gauge.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "storage.lab",
+ "value": "storage.lab"
+ },
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "domain",
+ "options": [
+ {
+ "selected": true,
+ "text": "storage.lab",
+ "value": "storage.lab"
+ }
+ ],
+ "query": "storage.lab",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "obj-rgw-1",
+ "value": "obj-rgw-1"
+ },
+ "hide": 2,
+ "includeAll": true,
+ "label": null,
+ "multi": true,
+ "name": "rgw_servers",
+ "options": [
+ {
+ "selected": true,
+ "text": "obj-rgw-1",
+ "value": "obj-rgw-1"
+ }
+ ],
+ "query": "obj-rgw-1",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "text": "95",
+ "value": "95"
+ },
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": true,
+ "name": "percentile",
+ "options": [
+ {
+ "selected": false,
+ "text": "90",
+ "value": "90"
+ },
+ {
+ "selected": true,
+ "text": "95",
+ "value": "95"
+ },
+ {
+ "selected": false,
+ "text": "98",
+ "value": "98"
+ }
+ ],
+ "query": "90,95,98",
+ "type": "custom"
+ }
+ ]
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "Ceph RGW Workload",
+ "version": 1
+ },
+ "meta": {
+ "canEdit": true,
+ "canSave": true,
+ "canStar": true,
+ "created": "2017-08-01T05:18:58Z",
+ "createdBy": "admin@localhost",
+ "expires": "0001-01-01T00:00:00Z",
+ "slug": "ceph-rgw-workload",
+ "type": "db",
+ "updated": "2017-08-01T20:58:52Z",
+ "updatedBy": "admin@localhost",
+ "version": 1
+ }
+}
\ No newline at end of file
--- /dev/null
+{
+ "dashboard": {
+ "annotations": {
+ "list": []
+ },
+ "editable": false,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": true,
+ "id": 10,
+ "links": [
+ {
+ "asDropdown": true,
+ "icon": "external link",
+ "tags": [
+ "overview"
+ ],
+ "title": "Shortcuts",
+ "type": "dashboards"
+ }
+ ],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 1,
+ "id": 8,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 12,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": null,
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 12,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.$osd_servers.$domain.cephmetrics.gauge.$ceph_cluster.osd.*.perf.util,1,\"maxSeries\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers OSD Hosts Disk Utilization Peak",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "All OSD Hosts",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 1,
+ "id": 5,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [
+ {
+ "dashUri": "db/osd-node-detail",
+ "dashboard": "OSD Node Detail",
+ "includeVars": true,
+ "keepTime": true,
+ "targetBlank": true,
+ "title": "$osd_servers Node Details",
+ "type": "dashboard"
+ }
+ ],
+ "minSpan": 3,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": "osd_servers",
+ "scopedVars": {
+ "osd_servers": {
+ "selected": false,
+ "text": "obj-osd-1",
+ "value": "obj-osd-1"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(percentileOfSeries(group(collectd.$osd_servers.$domain.cephmetrics.gauge.$ceph_cluster.osd.*.perf.util),$percentile),\"all disk busy @$percentile%ile\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers Disk Utilisation @ $percentile%ile",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 1,
+ "id": 6,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [
+ {
+ "dashUri": "db/osd-node-detail",
+ "dashboard": "OSD Node Detail",
+ "includeVars": true,
+ "keepTime": true,
+ "targetBlank": true,
+ "title": "$osd_servers Node Details",
+ "type": "dashboard"
+ }
+ ],
+ "minSpan": 3,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": null,
+ "repeatIteration": 1501621235322,
+ "repeatPanelId": 5,
+ "scopedVars": {
+ "osd_servers": {
+ "selected": false,
+ "text": "obj-osd-2",
+ "value": "obj-osd-2"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(percentileOfSeries(group(collectd.$osd_servers.$domain.cephmetrics.gauge.$ceph_cluster.osd.*.perf.util),$percentile),\"all disk busy @$percentile%ile\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers Disk Utilisation @ $percentile%ile",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 1,
+ "id": 7,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [
+ {
+ "dashUri": "db/osd-node-detail",
+ "dashboard": "OSD Node Detail",
+ "includeVars": true,
+ "keepTime": true,
+ "targetBlank": true,
+ "title": "$osd_servers Node Details",
+ "type": "dashboard"
+ }
+ ],
+ "minSpan": 3,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": null,
+ "repeatIteration": 1501621235322,
+ "repeatPanelId": 5,
+ "scopedVars": {
+ "osd_servers": {
+ "selected": false,
+ "text": "obj-osd-3",
+ "value": "obj-osd-3"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(percentileOfSeries(group(collectd.$osd_servers.$domain.cephmetrics.gauge.$ceph_cluster.osd.*.perf.util),$percentile),\"all disk busy @$percentile%ile\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers Disk Utilisation @ $percentile%ile",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Each OSD Host's $percentile%ile Disk Utilisation",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": false,
+ "title": "Dashboard Row",
+ "titleSize": "h6"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [
+ "overview"
+ ],
+ "templating": {
+ "list": [
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "text": "storage.lab",
+ "value": "storage.lab"
+ },
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "domain",
+ "options": [
+ {
+ "selected": true,
+ "text": "storage.lab",
+ "value": "storage.lab"
+ }
+ ],
+ "query": "storage.lab",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "ceph",
+ "value": "ceph"
+ },
+ "datasource": "Local",
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "ceph_cluster",
+ "options": [],
+ "query": "collectd.*.$domain.cephmetrics.gauge.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "text": "95",
+ "value": "95"
+ },
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "percentile",
+ "options": [
+ {
+ "selected": false,
+ "text": "80",
+ "value": "80"
+ },
+ {
+ "selected": false,
+ "text": "85",
+ "value": "85"
+ },
+ {
+ "selected": false,
+ "text": "90",
+ "value": "90"
+ },
+ {
+ "selected": true,
+ "text": "95",
+ "value": "95"
+ },
+ {
+ "selected": false,
+ "text": "98",
+ "value": "98"
+ }
+ ],
+ "query": "80,85,90,95,98",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "text": "All",
+ "value": "$__all"
+ },
+ "hide": 2,
+ "includeAll": true,
+ "label": null,
+ "multi": true,
+ "name": "osd_servers",
+ "options": [
+ {
+ "selected": true,
+ "text": "All",
+ "value": "$__all"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-1",
+ "value": "obj-osd-1"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-2",
+ "value": "obj-osd-2"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-3",
+ "value": "obj-osd-3"
+ }
+ ],
+ "query": "obj-osd-1,obj-osd-2,obj-osd-3",
+ "type": "custom"
+ }
+ ]
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "Disk Busy by Server",
+ "version": 2
+ },
+ "meta": {
+ "canEdit": true,
+ "canSave": true,
+ "canStar": true,
+ "created": "2017-08-01T05:18:58Z",
+ "createdBy": "admin@localhost",
+ "expires": "0001-01-01T00:00:00Z",
+ "slug": "disk-busy-by-server",
+ "type": "db",
+ "updated": "2017-08-01T21:02:25Z",
+ "updatedBy": "admin@localhost",
+ "version": 2
+ }
+}
\ No newline at end of file
--- /dev/null
+{
+ "dashboard": {
+ "annotations": {
+ "list": []
+ },
+ "editable": false,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": true,
+ "id": 12,
+ "links": [
+ {
+ "asDropdown": true,
+ "icon": "external link",
+ "tags": [
+ "overview"
+ ],
+ "title": "Shortcuts",
+ "type": "dashboards"
+ }
+ ],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 1,
+ "id": 8,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 12,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": null,
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 12,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.iops,1,\"sumSeries\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers OSD Server IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "All Servers by IOPS",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 1,
+ "id": 5,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [
+ {
+ "dashUri": "db/osd-node-detail",
+ "dashboard": "OSD Node Detail",
+ "includeVars": true,
+ "keepTime": true,
+ "targetBlank": true,
+ "title": "$osd_servers Node Details",
+ "type": "dashboard"
+ }
+ ],
+ "minSpan": 3,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": "osd_servers",
+ "scopedVars": {
+ "osd_servers": {
+ "selected": false,
+ "text": "obj-osd-1",
+ "value": "obj-osd-1"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(sumSeries(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.iops),\"total IOPS for all disks on $osd_servers\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers Total OSD IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 1,
+ "id": 6,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [
+ {
+ "dashUri": "db/osd-node-detail",
+ "dashboard": "OSD Node Detail",
+ "includeVars": true,
+ "keepTime": true,
+ "targetBlank": true,
+ "title": "$osd_servers Node Details",
+ "type": "dashboard"
+ }
+ ],
+ "minSpan": 3,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": null,
+ "repeatIteration": 1501622535508,
+ "repeatPanelId": 5,
+ "scopedVars": {
+ "osd_servers": {
+ "selected": false,
+ "text": "obj-osd-2",
+ "value": "obj-osd-2"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(sumSeries(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.iops),\"total IOPS for all disks on $osd_servers\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers Total OSD IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 1,
+ "id": 7,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [
+ {
+ "dashUri": "db/osd-node-detail",
+ "dashboard": "OSD Node Detail",
+ "includeVars": true,
+ "keepTime": true,
+ "targetBlank": true,
+ "title": "$osd_servers Node Details",
+ "type": "dashboard"
+ }
+ ],
+ "minSpan": 3,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": null,
+ "repeatIteration": 1501622535508,
+ "repeatPanelId": 5,
+ "scopedVars": {
+ "osd_servers": {
+ "selected": false,
+ "text": "obj-osd-3",
+ "value": "obj-osd-3"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(sumSeries(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.iops),\"total IOPS for all disks on $osd_servers\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers Total OSD IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Each OSD Node's IOPS Load",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": false,
+ "title": "Dashboard Row",
+ "titleSize": "h6"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [
+ "overview"
+ ],
+ "templating": {
+ "list": [
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "text": "storage.lab",
+ "value": "storage.lab"
+ },
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "domain",
+ "options": [
+ {
+ "selected": true,
+ "text": "storage.lab",
+ "value": "storage.lab"
+ }
+ ],
+ "query": "storage.lab",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "text": "ceph",
+ "value": "ceph"
+ },
+ "datasource": "Local",
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "cluster_name",
+ "options": [],
+ "query": "collectd.*.$domain.cephmetrics.gauge.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "text": "All",
+ "value": "$__all"
+ },
+ "hide": 2,
+ "includeAll": true,
+ "label": null,
+ "multi": true,
+ "name": "osd_servers",
+ "options": [
+ {
+ "selected": true,
+ "text": "All",
+ "value": "$__all"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-1",
+ "value": "obj-osd-1"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-2",
+ "value": "obj-osd-2"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-3",
+ "value": "obj-osd-3"
+ }
+ ],
+ "query": "obj-osd-1,obj-osd-2,obj-osd-3",
+ "type": "custom"
+ }
+ ]
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "IOPS by Server",
+ "version": 4
+ },
+ "meta": {
+ "canEdit": true,
+ "canSave": true,
+ "canStar": true,
+ "created": "2017-08-01T05:18:58Z",
+ "createdBy": "admin@localhost",
+ "expires": "0001-01-01T00:00:00Z",
+ "slug": "iops-by-server",
+ "type": "db",
+ "updated": "2017-08-01T21:23:04Z",
+ "updatedBy": "admin@localhost",
+ "version": 4
+ }
+}
\ No newline at end of file
--- /dev/null
+{
+ "dashboard": {
+ "annotations": {
+ "list": []
+ },
+ "editable": false,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": true,
+ "id": 28,
+ "links": [
+ {
+ "asDropdown": true,
+ "icon": "external link",
+ "tags": [
+ "overview"
+ ],
+ "title": "Shortcuts",
+ "type": "dashboards"
+ }
+ ],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": "200px",
+ "panels": [
+ {
+ "content": "",
+ "height": "100",
+ "id": 19,
+ "links": [],
+ "minSpan": 2,
+ "mode": "markdown",
+ "span": 2,
+ "title": "",
+ "transparent": true,
+ "type": "text"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": null,
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "100",
+ "id": 1,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": "1",
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.iscsi.gw_stats.tpg_count), \"max\"))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "Gateways",
+ "type": "singlestat",
+ "valueFontSize": "70%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": null,
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "100",
+ "id": 2,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": "1",
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.iscsi.gw_stats.client_count), \"max\"))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "Clients",
+ "type": "singlestat",
+ "valueFontSize": "70%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": null,
+ "description": "Sessions shows the number of iSCSI clients currently logged in to the gateway group",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "100",
+ "id": 5,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": "",
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "maxSeries(keepLastValue(consolidateBy(collectd.*.$domain.cephmetrics.gauge.$cluster_name.iscsi.gw_stats.sessions, \"max\")))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "Sessions",
+ "type": "singlestat",
+ "valueFontSize": "70%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": null,
+ "decimals": 0,
+ "description": "Capacity refers to the total capacity defined within the iSCSI gateway group, and available to iSCSI clients",
+ "format": "decbytes",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "100",
+ "id": 4,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": "1",
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "hide": false,
+ "refId": "A",
+ "target": "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.iscsi.gw_stats.capacity), \"max\"))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "Defined Capacity",
+ "type": "singlestat",
+ "valueFontSize": "70%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": null,
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "100",
+ "id": 3,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": "1",
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.iscsi.gw_stats.lun_count), \"max\"))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "LUNs",
+ "type": "singlestat",
+ "valueFontSize": "70%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": null,
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "100",
+ "id": 18,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": "",
+ "minSpan": 1,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 1,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "hide": true,
+ "refId": "A",
+ "target": "maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.iscsi.gw_stats.lun_count), \"max\"))",
+ "textEditor": true
+ },
+ {
+ "hide": true,
+ "refId": "B",
+ "target": "countSeries(groupByNode(keepLastValue(collectd.$iscsi_gateways.$domain.cephmetrics.gauge.$cluster_name.iscsi.gw_clients.$clients.luns.*.size),-2,\"maxSeries\"))",
+ "textEditor": true
+ },
+ {
+ "refId": "C",
+ "target": "diffSeries(#A,#B)",
+ "targetFull": "diffSeries(maxSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.iscsi.gw_stats.lun_count), \"max\")),countSeries(groupByNode(keepLastValue(collectd.$iscsi_gateways.$domain.cephmetrics.gauge.$cluster_name.iscsi.gw_clients.$clients.luns.*.size),-2,\"maxSeries\")))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "Unused LUNs",
+ "type": "singlestat",
+ "valueFontSize": "70%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "content": "",
+ "height": "100",
+ "id": 22,
+ "links": [],
+ "minSpan": 3,
+ "mode": "markdown",
+ "span": 3,
+ "title": "",
+ "transparent": true,
+ "type": "text"
+ },
+ {
+ "content": "",
+ "height": "100",
+ "id": 23,
+ "links": [],
+ "minSpan": 1,
+ "mode": "markdown",
+ "span": 1,
+ "title": "",
+ "transparent": true,
+ "type": "text"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": null,
+ "decimals": 0,
+ "description": "Total IOPS across all iSCSI gateways",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "200",
+ "id": 6,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": "",
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": true
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "sumSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.derive.$cluster_name.iscsi.gw_stats.iops), \"max\"))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "IOPS",
+ "type": "singlestat",
+ "valueFontSize": "70%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": null,
+ "decimals": 0,
+ "description": "Total read/write throughput across all iSCSI gateways",
+ "format": "decbytes",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "200",
+ "id": 7,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": "",
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": true
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "sumSeries(consolidateBy(keepLastValue(collectd.*.$domain.cephmetrics.derive.$cluster_name.iscsi.gw_stats.total_bytes_per_sec), \"max\"))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "Throughput",
+ "type": "singlestat",
+ "valueFontSize": "70%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 1,
+ "height": "",
+ "id": 14,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 2,
+ "links": [],
+ "minSpan": 3,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 3,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.$iscsi_gateways.$domain.interface.{bond,en,eth}*.if_octets.{tx,rx},1, \"sum\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Network Load by Gateway",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "cacheTimeout": null,
+ "combine": {
+ "label": "Others",
+ "threshold": 0
+ },
+ "datasource": null,
+ "fontSize": "80%",
+ "format": "short",
+ "height": "200",
+ "id": 26,
+ "interval": null,
+ "legend": {
+ "show": true,
+ "values": true
+ },
+ "legendType": "Right side",
+ "links": [],
+ "maxDataPoints": 3,
+ "minSpan": 3,
+ "nullPointMode": "connected",
+ "pieType": "pie",
+ "span": 3,
+ "strokeWidth": 1,
+ "targets": [
+ {
+ "hide": true,
+ "refId": "A",
+ "target": "keepLastValue(collectd.$iscsi_gateways.$domain.cephmetrics.gauge.$cluster_name.iscsi.gw_clients.*.luns.*.active_path)",
+ "textEditor": true
+ },
+ {
+ "refId": "B",
+ "target": "groupByNode(#A,1,\"sumSeries\")",
+ "targetFull": "groupByNode(keepLastValue(collectd.$iscsi_gateways.$domain.cephmetrics.gauge.$cluster_name.iscsi.gw_clients.*.luns.*.active_path),1,\"sumSeries\")",
+ "textEditor": true
+ }
+ ],
+ "title": "Primary LUN Paths Per Gateway",
+ "type": "grafana-piechart-panel",
+ "valueName": "current"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "iSCSI Gateway Group : $gw_name",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 0,
+ "height": "",
+ "id": 21,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 2,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.$iscsi_gateways.$domain.cephmetrics.derive.$cluster_name.iscsi.gw_stats.iops,1, \"sum\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "IOPS Load by Gateway",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "none",
+ "label": "IOPS",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 0,
+ "height": "",
+ "id": 27,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 2,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.$iscsi_gateways.$domain.cephmetrics.derive.$cluster_name.iscsi.gw_stats.total_bytes_per_sec,1, \"sum\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Throughput by Gateway",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": "Throughput",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 0,
+ "height": "",
+ "id": 12,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 2,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.$iscsi_gateways.$domain.cpu.percent.{interrupt,steal,system,user,wait},1, \"sum\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Gateway CPU Load",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "percent",
+ "label": "",
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 0,
+ "height": "",
+ "id": 24,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 2,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.$iscsi_gateways.$domain.memory.percent.used,1, \"sum\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Gateway Memory Usage",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "percent",
+ "label": "",
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Gateway Load",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 0,
+ "id": 8,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.*.$domain.cephmetrics.derive.$cluster_name.iscsi.gw_clients.$clients.luns.*.iops,-4,\"sum\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "IOPS by Client",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "none",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 0,
+ "id": 11,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.*.$domain.cephmetrics.derive.$cluster_name.iscsi.gw_clients.$clients.luns.*.total_bytes_per_sec,-4,\"sum\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Throughput by Client",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 0,
+ "id": 30,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "limit(groupByNode(collectd.*.$domain.cephmetrics.derive.$cluster_name.iscsi.gw_clients.$clients.luns.*.iops,-2,\"sum\"),10)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "IOPS by RBD Image for Client '$clients'",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "none",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 0,
+ "id": 31,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "limit(groupByNode(collectd.*.$domain.cephmetrics.derive.$cluster_name.iscsi.gw_clients.$clients.luns.*.total_bytes_per_sec,-2,\"sum\"),10)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Throughput by RBD Image for Client '$clients'",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Client Load : '$clients'",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "fontSize": "100%",
+ "id": 15,
+ "links": [],
+ "minSpan": 4,
+ "pageSize": 10,
+ "scroll": false,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": true
+ },
+ "span": 4,
+ "styles": [
+ {
+ "alias": "Time",
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "alias": "Disk (pool-image)",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Metric",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ },
+ {
+ "alias": "Size",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Current",
+ "thresholds": [],
+ "type": "number",
+ "unit": "bytes"
+ },
+ {
+ "alias": "",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 2,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(maximumAbove(collectd.*.$domain.cephmetrics.gauge.$cluster_name.iscsi.gw_clients.$clients.luns.*.size,0),-2,\"maxSeries\")",
+ "textEditor": true
+ }
+ ],
+ "title": "RBD Images Masked to '$clients'",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "fontSize": "100%",
+ "id": 16,
+ "links": [],
+ "minSpan": 4,
+ "pageSize": 10,
+ "scroll": false,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": true
+ },
+ "span": 4,
+ "styles": [
+ {
+ "alias": "Time",
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "alias": "Client",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Metric",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ },
+ {
+ "alias": "# Luns Masked",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 0,
+ "pattern": "Current",
+ "thresholds": [],
+ "type": "number",
+ "unit": "none"
+ },
+ {
+ "alias": "",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 2,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(keepLastValue(collectd.*.$domain.cephmetrics.gauge.$cluster_name.iscsi.gw_clients.$clients.lun_count),-2,\"maxSeries\")",
+ "textEditor": true
+ }
+ ],
+ "title": "Luns Per Client",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "fontSize": "100%",
+ "id": 17,
+ "links": [],
+ "maxDataPoints": "1",
+ "minSpan": 4,
+ "pageSize": 10,
+ "scroll": false,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": true
+ },
+ "span": 4,
+ "styles": [
+ {
+ "alias": "Time",
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "alias": "Client",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Metric",
+ "thresholds": [],
+ "type": "hidden",
+ "unit": "short"
+ },
+ {
+ "alias": "Capacity",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Current",
+ "thresholds": [],
+ "type": "number",
+ "unit": "bytes"
+ },
+ {
+ "alias": "",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "decimals": 2,
+ "pattern": "/.*/",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "sumSeries(groupByNode(keepLastValue(collectd.$iscsi_gateways.$domain.cephmetrics.gauge.$cluster_name.iscsi.gw_clients.$clients.luns.*.size),-2,\"maxSeries\"))",
+ "textEditor": true
+ }
+ ],
+ "title": "Client '$clients' - Masked Capacity",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Client Configuration : '$clients'",
+ "titleSize": "h5"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [],
+ "templating": {
+ "list": [
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "text": "test.lab",
+ "value": "test.lab"
+ },
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "domain",
+ "options": [
+ {
+ "selected": true,
+ "text": "test.lab",
+ "value": "test.lab"
+ }
+ ],
+ "query": "test.lab",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "ceph",
+ "value": "ceph"
+ },
+ "datasource": "Local",
+ "hide": 0,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "cluster_name",
+ "options": [],
+ "query": "collectd.*.$domain.cephmetrics.gauge.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {
+ "tags": [],
+ "text": "All",
+ "value": "$__all"
+ },
+ "datasource": "Local",
+ "hide": 0,
+ "includeAll": true,
+ "label": "iSCSI Client",
+ "multi": false,
+ "name": "clients",
+ "options": [],
+ "query": "collectd.*.$domain.cephmetrics.gauge.$cluster_name.iscsi.gw_clients.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "iqn-2003-01-com-redhat-iscsi-gw_ceph-gw",
+ "value": "iqn-2003-01-com-redhat-iscsi-gw_ceph-gw"
+ },
+ "datasource": "Local",
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "gw_name",
+ "options": [],
+ "query": "collectd.*.$domain.cephmetrics.gauge.$cluster_name.iscsi.gw_name.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "All",
+ "value": [
+ "$__all"
+ ]
+ },
+ "hide": 2,
+ "includeAll": true,
+ "label": null,
+ "multi": true,
+ "name": "iscsi_gateways",
+ "options": [
+ {
+ "selected": true,
+ "text": "All",
+ "value": "$__all"
+ },
+ {
+ "selected": false,
+ "text": "rh7-gw1",
+ "value": "rh7-gw1"
+ },
+ {
+ "selected": false,
+ "text": "rh7-gw2",
+ "value": "rh7-gw2"
+ }
+ ],
+ "query": "rh7-gw1, rh7-gw2",
+ "type": "custom"
+ }
+ ]
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "iSCSI Overview",
+ "version": 41
+ },
+ "meta": {
+ "canEdit": true,
+ "canSave": true,
+ "canStar": true,
+ "created": "2017-08-03T23:35:37Z",
+ "createdBy": "admin",
+ "expires": "0001-01-01T00:00:00Z",
+ "slug": "iscsi-overview",
+ "type": "db",
+ "updated": "2017-08-07T23:20:49Z",
+ "updatedBy": "admin",
+ "version": 41
+ }
+}
\ No newline at end of file
--- /dev/null
+{
+ "dashboard": {
+ "annotations": {
+ "list": []
+ },
+ "editable": false,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": true,
+ "id": 13,
+ "links": [
+ {
+ "asDropdown": true,
+ "icon": "external link",
+ "tags": [
+ "overview"
+ ],
+ "title": "Shortcuts",
+ "type": "dashboards"
+ }
+ ],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 1,
+ "id": 8,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 12,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": null,
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 12,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.await,1,\"maxSeries\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers OSD Hosts - Highest Latency",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "ms",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "All OSD Hosts",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 1,
+ "id": 5,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [
+ {
+ "dashUri": "db/osd-node-detail",
+ "dashboard": "OSD Node Detail",
+ "includeVars": true,
+ "keepTime": true,
+ "targetBlank": true,
+ "title": "$osd_servers Node Details",
+ "type": "dashboard"
+ }
+ ],
+ "minSpan": 3,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": "osd_servers",
+ "scopedVars": {
+ "osd_servers": {
+ "selected": false,
+ "text": "obj-osd-1",
+ "value": "obj-osd-1"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(maxSeries(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.await),\"$osd_servers Max Latency\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers Max Latency",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "ms",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 1,
+ "id": 6,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [
+ {
+ "dashUri": "db/osd-node-detail",
+ "dashboard": "OSD Node Detail",
+ "includeVars": true,
+ "keepTime": true,
+ "targetBlank": true,
+ "title": "$osd_servers Node Details",
+ "type": "dashboard"
+ }
+ ],
+ "minSpan": 3,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": null,
+ "repeatIteration": 1501621443172,
+ "repeatPanelId": 5,
+ "scopedVars": {
+ "osd_servers": {
+ "selected": false,
+ "text": "obj-osd-2",
+ "value": "obj-osd-2"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(maxSeries(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.await),\"$osd_servers Max Latency\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers Max Latency",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "ms",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 1,
+ "id": 7,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": false,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [
+ {
+ "dashUri": "db/osd-node-detail",
+ "dashboard": "OSD Node Detail",
+ "includeVars": true,
+ "keepTime": true,
+ "targetBlank": true,
+ "title": "$osd_servers Node Details",
+ "type": "dashboard"
+ }
+ ],
+ "minSpan": 3,
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": null,
+ "repeatIteration": 1501621443172,
+ "repeatPanelId": 5,
+ "scopedVars": {
+ "osd_servers": {
+ "selected": false,
+ "text": "obj-osd-3",
+ "value": "obj-osd-3"
+ }
+ },
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 4,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(maxSeries(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.await),\"$osd_servers Max Latency\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers Max Latency",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "ms",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Each OSD Host's Max Disk Latency",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": false,
+ "height": 250,
+ "panels": [],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": false,
+ "title": "Dashboard Row",
+ "titleSize": "h6"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [
+ "overview"
+ ],
+ "templating": {
+ "list": [
+ {
+ "allValue": null,
+ "current": {
+ "text": "storage.lab",
+ "value": "storage.lab"
+ },
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "domain",
+ "options": [
+ {
+ "selected": true,
+ "text": "storage.lab",
+ "value": "storage.lab"
+ }
+ ],
+ "query": "storage.lab",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "ceph",
+ "value": "ceph"
+ },
+ "datasource": "Local",
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "cluster_name",
+ "options": [],
+ "query": "collectd.*.$domain.cephmetrics.gauge.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "text": "All",
+ "value": "$__all"
+ },
+ "hide": 2,
+ "includeAll": true,
+ "label": null,
+ "multi": true,
+ "name": "osd_servers",
+ "options": [
+ {
+ "selected": true,
+ "text": "All",
+ "value": "$__all"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-1",
+ "value": "obj-osd-1"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-2",
+ "value": "obj-osd-2"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-3",
+ "value": "obj-osd-3"
+ }
+ ],
+ "query": "obj-osd-1,obj-osd-2,obj-osd-3",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "text": "95",
+ "value": "95"
+ },
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "percentile",
+ "options": [
+ {
+ "selected": true,
+ "text": "95",
+ "value": "95"
+ }
+ ],
+ "query": "95",
+ "type": "custom"
+ }
+ ]
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "Latency by Server",
+ "version": 3
+ },
+ "meta": {
+ "canEdit": true,
+ "canSave": true,
+ "canStar": true,
+ "created": "2017-08-01T05:18:58Z",
+ "createdBy": "admin@localhost",
+ "expires": "0001-01-01T00:00:00Z",
+ "slug": "latency-by-server",
+ "type": "db",
+ "updated": "2017-08-01T21:04:34Z",
+ "updatedBy": "admin@localhost",
+ "version": 3
+ }
+}
\ No newline at end of file
--- /dev/null
+{
+ "dashboard": {
+ "annotations": {
+ "list": []
+ },
+ "editable": false,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": true,
+ "id": 73,
+ "links": [
+ {
+ "asDropdown": true,
+ "icon": "external link",
+ "tags": [
+ "overview"
+ ],
+ "title": "Shortcuts",
+ "type": "dashboards"
+ }
+ ],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": "300px",
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "description": "Shows the total transmit and receive throughput to all interfaces across the Ceph hosts.",
+ "fill": 1,
+ "height": "",
+ "id": 1,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [
+ {
+ "dashUri": "db/osd-node-detail",
+ "dashboard": "OSD Node Detail",
+ "includeVars": true,
+ "keepTime": true,
+ "targetBlank": true,
+ "title": "OSD Host Details",
+ "type": "dashboard"
+ }
+ ],
+ "minSpan": 12,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 12,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "alias(sumSeries(groupByNode(collectd.$osd_servers.$domain.interface.*.if_octets.*,1,\"sumSeries\")),\"OSD Hosts\")",
+ "textEditor": true
+ },
+ {
+ "refId": "B",
+ "target": "alias(sumSeries(groupByNode(collectd.$rgw_servers.$domain.interface.*.if_octets.*,1,\"sumSeries\")),\"RadosGW Hosts\")",
+ "textEditor": true
+ },
+ {
+ "refId": "C",
+ "target": "alias(sumSeries(groupByNode(collectd.$mon_servers.$domain.interface.*.if_octets.*,1,\"sumSeries\")),\"MON Hosts\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Cluster Network Load Across MON, OSD and RADOSGW Hosts",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "Aggregated Network Load",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": "250",
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 1,
+ "id": 4,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 12,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.$mon_servers.$domain.interface.*.if_octets.*,1,\"sumSeries\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "Ceph MON Network Load",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "MON Hosts",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": "250",
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 1,
+ "id": 2,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 12,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.$osd_servers.$domain.interface.*.if_octets.*,1,\"sumSeries\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "OSD Host Network Load",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "OSD Hosts",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": "250",
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": null,
+ "fill": 1,
+ "id": 3,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "nullPointMode": "null",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 12,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "groupByNode(collectd.$rgw_servers.$domain.interface.*.if_octets.*,1,\"sumSeries\")",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "RadosGW Network Load",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": true
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "RadosGW Hosts",
+ "titleSize": "h5"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [
+ "overview"
+ ],
+ "templating": {
+ "list": [
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "text": "All",
+ "value": "$__all"
+ },
+ "hide": 0,
+ "includeAll": true,
+ "label": "OSD Hostname",
+ "multi": true,
+ "name": "osd_servers",
+ "options": [
+ {
+ "selected": true,
+ "text": "All",
+ "value": "$__all"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-1",
+ "value": "obj-osd-1"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-2",
+ "value": "obj-osd-2"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-3",
+ "value": "obj-osd-3"
+ }
+ ],
+ "query": "obj-osd-1,obj-osd-2,obj-osd-3",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "storage.lab",
+ "value": "storage.lab"
+ },
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "domain",
+ "options": [
+ {
+ "selected": true,
+ "text": "storage.lab",
+ "value": "storage.lab"
+ }
+ ],
+ "query": "storage.lab",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "ceph",
+ "value": "ceph"
+ },
+ "datasource": "Local",
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "cluster_name",
+ "options": [],
+ "query": "collectd.*.$domain.cephmetrics.gauge.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "All",
+ "value": "$__all"
+ },
+ "datasource": "Local",
+ "hide": 0,
+ "includeAll": true,
+ "label": "Monitor Host",
+ "multi": false,
+ "name": "mon_servers",
+ "options": [],
+ "query": "collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.mon_status.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "obj-rgw-1",
+ "value": "obj-rgw-1"
+ },
+ "hide": 0,
+ "includeAll": true,
+ "label": "RadosGW Host",
+ "multi": false,
+ "name": "rgw_servers",
+ "options": [
+ {
+ "selected": true,
+ "text": "obj-rgw-1",
+ "value": "obj-rgw-1"
+ }
+ ],
+ "query": "obj-rgw-1",
+ "type": "custom"
+ }
+ ]
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "Network Usage by Node",
+ "version": 1
+ },
+ "meta": {
+ "canEdit": true,
+ "canSave": true,
+ "canStar": true,
+ "created": "2017-08-02T01:47:18Z",
+ "createdBy": "admin@localhost",
+ "expires": "0001-01-01T00:00:00Z",
+ "slug": "network-usage-by-node",
+ "type": "db",
+ "updated": "2017-08-03T04:16:09Z",
+ "updatedBy": "admin@localhost",
+ "version": 1
+ }
+}
\ No newline at end of file
--- /dev/null
+{
+ "dashboard": {
+ "annotations": {
+ "list": []
+ },
+ "editable": false,
+ "gnetId": null,
+ "graphTooltip": 0,
+ "hideControls": true,
+ "id": 51,
+ "links": [
+ {
+ "asDropdown": true,
+ "icon": "external link",
+ "tags": [
+ "overview"
+ ],
+ "title": "Shortcuts",
+ "type": "dashboards"
+ }
+ ],
+ "refresh": "10s",
+ "rows": [
+ {
+ "collapse": false,
+ "height": 125,
+ "panels": [
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "Local",
+ "format": "none",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "160",
+ "id": 9,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": "",
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "sumSeries(keepLastValue(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.num_osds,6))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "OSDs",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "cacheTimeout": null,
+ "colorBackground": false,
+ "colorValue": false,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "datasource": "Local",
+ "decimals": 0,
+ "description": "Show the raw capacity across all OSD's on the selected Hosts.",
+ "format": "decbytes",
+ "gauge": {
+ "maxValue": 100,
+ "minValue": 0,
+ "show": false,
+ "thresholdLabels": false,
+ "thresholdMarkers": true
+ },
+ "height": "160",
+ "id": 15,
+ "interval": null,
+ "links": [],
+ "mappingType": 1,
+ "mappingTypes": [
+ {
+ "name": "value to text",
+ "value": 1
+ },
+ {
+ "name": "range to text",
+ "value": 2
+ }
+ ],
+ "maxDataPoints": "1",
+ "minSpan": 2,
+ "nullPointMode": "connected",
+ "nullText": null,
+ "postfix": "",
+ "postfixFontSize": "50%",
+ "prefix": "",
+ "prefixFontSize": "50%",
+ "rangeMaps": [
+ {
+ "from": "null",
+ "text": "N/A",
+ "to": "null"
+ }
+ ],
+ "span": 2,
+ "sparkline": {
+ "fillColor": "rgba(31, 118, 189, 0.18)",
+ "full": false,
+ "lineColor": "rgb(31, 120, 193)",
+ "show": false
+ },
+ "tableColumn": "",
+ "targets": [
+ {
+ "refId": "A",
+ "target": "sumSeries(consolidateBy(keepLastValue(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.stat_bytes, 6), \"sum\"))",
+ "textEditor": true
+ }
+ ],
+ "thresholds": "",
+ "title": "Raw Capacity",
+ "type": "singlestat",
+ "valueFontSize": "80%",
+ "valueMaps": [
+ {
+ "op": "=",
+ "text": "N/A",
+ "value": "null"
+ }
+ ],
+ "valueName": "current"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "description": "",
+ "fontSize": "100%",
+ "height": "160",
+ "id": 14,
+ "links": [],
+ "minSpan": 3,
+ "pageSize": 1000,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": false
+ },
+ "span": 3,
+ "styles": [
+ {
+ "alias": "Time",
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "alias": "Host and Disk",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Metric",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ },
+ {
+ "alias": "OSD ID",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 0,
+ "pattern": "Current",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.$device_id.osd_id,1,-2)",
+ "textEditor": true
+ }
+ ],
+ "title": "",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ },
+ {
+ "columns": [
+ {
+ "text": "Current",
+ "value": "current"
+ }
+ ],
+ "description": "",
+ "fontSize": "100%",
+ "height": "160",
+ "id": 16,
+ "links": [],
+ "maxDataPoints": "1",
+ "minSpan": 3,
+ "pageSize": 1000,
+ "scroll": true,
+ "showHeader": true,
+ "sort": {
+ "col": 0,
+ "desc": false
+ },
+ "span": 3,
+ "styles": [
+ {
+ "alias": "Time",
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "pattern": "Time",
+ "type": "date"
+ },
+ {
+ "alias": "Host and Disk",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 2,
+ "pattern": "Metric",
+ "thresholds": [],
+ "type": "number",
+ "unit": "short"
+ },
+ {
+ "alias": "Disk Size",
+ "colorMode": null,
+ "colors": [
+ "rgba(245, 54, 54, 0.9)",
+ "rgba(237, 129, 40, 0.89)",
+ "rgba(50, 172, 45, 0.97)"
+ ],
+ "dateFormat": "YYYY-MM-DD HH:mm:ss",
+ "decimals": 0,
+ "pattern": "Current",
+ "thresholds": [],
+ "type": "number",
+ "unit": "decbytes"
+ }
+ ],
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(keepLastValue(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.$device_id.fs_size),1,-2)",
+ "textEditor": true
+ }
+ ],
+ "title": "",
+ "transform": "timeseries_aggregations",
+ "type": "table"
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "'$osd_servers' OSD Overview",
+ "titleSize": "h5"
+ },
+ {
+ "collapse": true,
+ "height": 250,
+ "panels": [
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 1,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(limit(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.$device_id.perf.util, $max_devices), -3)",
+ "textEditor": false
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers Disk utilisation",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "%Util",
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 5,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(limit(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.$device_id.perf.iops, $max_devices), -3)"
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers Disk IOPS",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "IOPS",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 2,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(limit(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.$device_id.perf.await, $max_devices), -3)",
+ "textEditor": false
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers Disk Latency",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "none",
+ "label": "ms",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 3,
+ "legend": {
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": false,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(limit(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.$device_id.perf.bytes_per_sec, $max_devices), -3)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers Throughput by Disk",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "decbytes",
+ "label": "",
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {
+ "interrupt": "#447EBC",
+ "steal": "#6D1F62",
+ "system": "#890F02",
+ "user": "#3F6833",
+ "wait": "#C15C17"
+ },
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "description": "Shows the CPU breakdown. When multiple servers are selected, only the first host's cpu data is shown",
+ "fill": 3,
+ "id": 6,
+ "legend": {
+ "alignAsTable": false,
+ "avg": false,
+ "current": false,
+ "max": false,
+ "min": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "repeat": null,
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "limit(aliasByMetric(collectd.$osd_servers.$domain.cpu.percent.{system,user,wait,steal,nice,interrupt,softirq}),7)",
+ "textEditor": true
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers CPU Utilisation",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "short",
+ "label": "",
+ "logBase": 1,
+ "max": "100",
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ },
+ {
+ "aliasColors": {},
+ "bars": false,
+ "dashLength": 10,
+ "dashes": false,
+ "datasource": "Local",
+ "fill": 1,
+ "id": 7,
+ "legend": {
+ "alignAsTable": false,
+ "avg": false,
+ "current": false,
+ "hideZero": true,
+ "max": false,
+ "min": false,
+ "rightSide": false,
+ "show": true,
+ "total": false,
+ "values": false
+ },
+ "lines": true,
+ "linewidth": 1,
+ "links": [],
+ "minSpan": 6,
+ "nullPointMode": "connected",
+ "percentage": false,
+ "pointradius": 5,
+ "points": false,
+ "renderer": "flot",
+ "seriesOverrides": [],
+ "spaceLength": 10,
+ "span": 6,
+ "stack": true,
+ "steppedLine": false,
+ "targets": [
+ {
+ "refId": "A",
+ "target": "aliasByNode(limit(collectd.$osd_servers.$domain.interface.{eth,en,bond}*.if_octets.*, 40), -3, -1)",
+ "textEditor": false
+ }
+ ],
+ "thresholds": [],
+ "timeFrom": null,
+ "timeShift": null,
+ "title": "$osd_servers Network Load",
+ "tooltip": {
+ "shared": true,
+ "sort": 0,
+ "value_type": "individual"
+ },
+ "type": "graph",
+ "xaxis": {
+ "buckets": null,
+ "mode": "time",
+ "name": null,
+ "show": true,
+ "values": []
+ },
+ "yaxes": [
+ {
+ "format": "bytes",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": "0",
+ "show": true
+ },
+ {
+ "format": "short",
+ "label": null,
+ "logBase": 1,
+ "max": null,
+ "min": null,
+ "show": false
+ }
+ ]
+ }
+ ],
+ "repeat": null,
+ "repeatIteration": null,
+ "repeatRowId": null,
+ "showTitle": true,
+ "title": "'$osd_servers' Performance Statistics",
+ "titleSize": "h5"
+ }
+ ],
+ "schemaVersion": 14,
+ "style": "dark",
+ "tags": [
+ "overview"
+ ],
+ "templating": {
+ "list": [
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "tags": [],
+ "text": "All",
+ "value": "$__all"
+ },
+ "hide": 0,
+ "includeAll": true,
+ "label": "OSD Host Name",
+ "multi": false,
+ "name": "osd_servers",
+ "options": [
+ {
+ "selected": true,
+ "text": "All",
+ "value": "$__all"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-1",
+ "value": "obj-osd-1"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-2",
+ "value": "obj-osd-2"
+ },
+ {
+ "selected": false,
+ "text": "obj-osd-3",
+ "value": "obj-osd-3"
+ }
+ ],
+ "query": "obj-osd-1,obj-osd-2,obj-osd-3",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "storage.lab",
+ "value": "storage.lab"
+ },
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "domain",
+ "options": [
+ {
+ "selected": true,
+ "text": "storage.lab",
+ "value": "storage.lab"
+ }
+ ],
+ "query": "storage.lab",
+ "type": "custom"
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "ceph",
+ "value": "ceph"
+ },
+ "datasource": "Local",
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "cluster_name",
+ "options": [],
+ "query": "collectd.*.$domain.cephmetrics.gauge.*",
+ "refresh": 1,
+ "regex": "",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {
+ "text": "All",
+ "value": "$__all"
+ },
+ "datasource": "Local",
+ "hide": 0,
+ "includeAll": true,
+ "label": "Disk Name",
+ "multi": true,
+ "name": "device_id",
+ "options": [],
+ "query": "collectd.$osd_servers.$domain.cephmetrics.gauge.ceph.osd.*",
+ "refresh": 1,
+ "regex": "/^[^\\d].*/",
+ "sort": 0,
+ "tagValuesQuery": "",
+ "tags": [],
+ "tagsQuery": "",
+ "type": "query",
+ "useTags": false
+ },
+ {
+ "allValue": null,
+ "current": {
+ "selected": true,
+ "text": "60",
+ "value": "60"
+ },
+ "hide": 2,
+ "includeAll": false,
+ "label": null,
+ "multi": false,
+ "name": "max_devices",
+ "options": [
+ {
+ "selected": true,
+ "text": "60",
+ "value": "60"
+ }
+ ],
+ "query": "60",
+ "type": "custom"
+ }
+ ]
+ },
+ "time": {
+ "from": "now-1h",
+ "to": "now"
+ },
+ "timepicker": {
+ "refresh_intervals": [
+ "5s",
+ "10s",
+ "30s",
+ "1m",
+ "5m",
+ "15m",
+ "30m",
+ "1h",
+ "2h",
+ "1d"
+ ],
+ "time_options": [
+ "5m",
+ "15m",
+ "1h",
+ "6h",
+ "12h",
+ "24h",
+ "2d",
+ "7d",
+ "30d"
+ ]
+ },
+ "timezone": "browser",
+ "title": "OSD Node Detail",
+ "version": 7
+ },
+ "meta": {
+ "canEdit": true,
+ "canSave": true,
+ "canStar": true,
+ "created": "2017-08-01T05:18:58Z",
+ "createdBy": "admin@localhost",
+ "expires": "0001-01-01T00:00:00Z",
+ "slug": "osd-node-detail",
+ "type": "db",
+ "updated": "2017-08-01T21:12:50Z",
+ "updatedBy": "admin@localhost",
+ "version": 7
+ }
+}
\ No newline at end of file
--- /dev/null
+version: '2'
+
+services:
+ grafana:
+ image: docker.io/grafana/grafana:latest
+ container_name: grafana
+ ports:
+ - "3000:3000"
+ volumes:
+ - /opt/docker/grafana/etc:/etc/grafana:Z
+ - /opt/docker/grafana/data:/var/lib/grafana:Z
+ depends_on:
+ - graphite
+ graphite:
+ image: docker.io/abezhenar/graphite-centos7
+ container_name: graphite
+ ports:
+ - "80:80"
+ - "2003:2003"
+ - "2004:2004"
+ - "7002:7002"
+ volumes:
+ - /opt/docker/graphite:/var/lib/graphite/storage/whisper:Z
--- /dev/null
+# Hostname "obj-mon-1.storage.lab"
+BaseDir "/var/lib/collectd"
+PluginDir "/usr/lib64/collectd"
+
+TypesDB "/usr/share/collectd/types.db"
+
+Interval 10
+Timeout 5
+ReadThreads 5
+
+<LoadPlugin python>
+ Globals true
+</LoadPlugin>
+
+LoadPlugin "threshold"
+LoadPlugin "aggregation"
+
+Include "/etc/collectd.d/*.conf"
--- /dev/null
+LoadPlugin "python"
+
+<Plugin python>
+ ModulePath "/usr/lib64/collectd/cephmetrics"
+
+ Import "cephmetrics"
+ <Module cephmetrics>
+ ClusterName "ceph"
+ </Module>
+</Plugin>
--- /dev/null
+LoadPlugin cpu
+
+<Plugin cpu>
+ ValuesPercentage true
+ ReportByCpu false
+</Plugin>
+
+<Plugin "threshold">
+ <Plugin "cpu">
+ <Type "percent">
+ Instance user
+ FailureMax 90
+ WarningMax 80
+ </Type>
+ </Plugin>
+</Plugin>
+
--- /dev/null
+LoadPlugin memory
+
+<Plugin "memory">
+ ValuesPercentage true
+</Plugin>
+
+<Plugin "aggregation">
+ <Aggregation>
+ Plugin "memory"
+ Type "memory"
+
+ GroupBy "Host"
+
+ CalculateSum true
+ </Aggregation>
+</Plugin>
+
+<Plugin "threshold">
+ <Plugin "memory">
+ <Type "percent">
+ Instance used
+ FailureMax 90
+ WarningMax 80
+ </Type>
+ </Plugin>
+</Plugin>
--- /dev/null
+LoadPlugin interface
--- /dev/null
+LoadPlugin "write_graphite"
+<Plugin write_graphite>
+ <Node "ceph_grafana">
+ Host "graphite.storage.lab"
+ Port "2003"
+ Protocol "tcp"
+# ReconnectInterval 0
+ LogSendErrors true
+ Prefix "collectd."
+# Postfix "collectd"
+ StoreRates true
+ AlwaysAppendDS false
+ EscapeCharacter "_"
+ PreserveSeparator true
+ SeparateInstances true
+# DropDuplicateFields true
+ </Node>
+</Plugin>
+
--- /dev/null
+##################### Grafana Configuration Example #####################
+#
+# Everything has defaults so you only need to uncomment things you want to
+# change
+
+# possible values : production, development
+; app_mode = production
+
+# instance name, defaults to HOSTNAME environment variable value or hostname if HOSTNAME var is empty
+; instance_name = ${HOSTNAME}
+
+#################################### Paths ####################################
+[paths]
+# Path to where grafana can store temp files, sessions, and the sqlite3 db (if that is used)
+#
+;data = /var/lib/grafana
+#
+# Directory where grafana can store logs
+#
+;logs = /var/log/grafana
+#
+# Directory where grafana will automatically scan and look for plugins
+#
+;plugins = /var/lib/grafana/plugins
+
+#
+#################################### Server ####################################
+[server]
+# Protocol (http, https, socket)
+;protocol = http
+
+# The ip address to bind to, empty will bind to all interfaces
+;http_addr =
+
+# The http port to use
+;http_port = 3000
+
+# The public facing domain name used to access grafana from a browser
+;domain = localhost
+
+# Redirect to correct domain if host header does not match domain
+# Prevents DNS rebinding attacks
+;enforce_domain = false
+
+# The full public facing url you use in browser, used for redirects and emails
+# If you use reverse proxy and sub path specify full url (with sub path)
+;root_url = http://localhost:3000
+root_url = %(protocol)s://%(domain)s:%(http_port)s/
+
+# Log web requests
+;router_logging = false
+
+# the path relative working path
+;static_root_path = public
+
+# enable gzip
+;enable_gzip = false
+
+# https certs & key file
+;cert_file =
+;cert_key =
+
+# Unix socket path
+;socket =
+
+#################################### Database ####################################
+[database]
+# You can configure the database connection by specifying type, host, name, user and password
+# as seperate properties or as on string using the url propertie.
+
+# Either "mysql", "postgres" or "sqlite3", it's your choice
+;type = sqlite3
+;host = 127.0.0.1:3306
+;name = grafana
+;user = root
+# If the password contains # or ; you have to wrap it with trippel quotes. Ex """#password;"""
+;password =
+
+# Use either URL or the previous fields to configure the database
+# Example: mysql://user:secret@host:port/database
+;url =
+
+# For "postgres" only, either "disable", "require" or "verify-full"
+;ssl_mode = disable
+
+# For "sqlite3" only, path relative to data_path setting
+;path = grafana.db
+
+# Max conn setting default is 0 (mean not set)
+;max_idle_conn =
+;max_open_conn =
+
+
+#################################### Session ####################################
+[session]
+# Either "memory", "file", "redis", "mysql", "postgres", default is "file"
+;provider = file
+
+# Provider config options
+# memory: not have any config yet
+# file: session dir path, is relative to grafana data_path
+# redis: config like redis server e.g. `addr=127.0.0.1:6379,pool_size=100,db=grafana`
+# mysql: go-sql-driver/mysql dsn config string, e.g. `user:password@tcp(127.0.0.1:3306)/database_name`
+# postgres: user=a password=b host=localhost port=5432 dbname=c sslmode=disable
+;provider_config = sessions
+
+# Session cookie name
+;cookie_name = grafana_sess
+
+# If you use session in https only, default is false
+;cookie_secure = false
+
+# Session life time, default is 86400
+;session_life_time = 86400
+
+#################################### Data proxy ###########################
+[dataproxy]
+
+# This enables data proxy logging, default is false
+;logging = false
+
+
+#################################### Analytics ####################################
+[analytics]
+# Server reporting, sends usage counters to stats.grafana.org every 24 hours.
+# No ip addresses are being tracked, only simple counters to track
+# running instances, dashboard and error counts. It is very helpful to us.
+# Change this option to false to disable reporting.
+;reporting_enabled = true
+
+# Set to false to disable all checks to https://grafana.net
+# for new vesions (grafana itself and plugins), check is used
+# in some UI views to notify that grafana or plugin update exists
+# This option does not cause any auto updates, nor send any information
+# only a GET request to http://grafana.com to get latest versions
+;check_for_updates = true
+
+# Google Analytics universal tracking code, only enabled if you specify an id here
+;google_analytics_ua_id =
+
+#################################### Security ####################################
+[security]
+# default admin user, created on startup
+;admin_user = admin
+
+# default admin password, can be changed before first start of grafana, or in profile settings
+;admin_password = admin
+
+# used for signing
+;secret_key = SW2YcwTIb9zpOOhoPsMm
+
+# Auto-login remember days
+;login_remember_days = 7
+;cookie_username = grafana_user
+;cookie_remember_name = grafana_remember
+
+# disable gravatar profile images
+;disable_gravatar = false
+
+# data source proxy whitelist (ip_or_domain:port separated by spaces)
+;data_source_proxy_whitelist =
+
+[snapshots]
+# snapshot sharing options
+;external_enabled = true
+;external_snapshot_url = https://snapshots-origin.raintank.io
+;external_snapshot_name = Publish to snapshot.raintank.io
+
+# remove expired snapshot
+;snapshot_remove_expired = true
+
+# remove snapshots after 90 days
+;snapshot_TTL_days = 90
+
+#################################### Users ####################################
+[users]
+# disable user signup / registration
+;allow_sign_up = true
+
+# Allow non admin users to create organizations
+;allow_org_create = true
+
+# Set to true to automatically assign new users to the default organization (id 1)
+;auto_assign_org = true
+
+# Default role new users will be automatically assigned (if disabled above is set to true)
+;auto_assign_org_role = Viewer
+
+# Background text for the user field on the login page
+;login_hint = email or username
+
+# Default UI theme ("dark" or "light")
+;default_theme = dark
+
+[auth]
+# Set to true to disable (hide) the login form, useful if you use OAuth, defaults to false
+;disable_login_form = false
+
+# Set to true to disable the signout link in the side menu. useful if you use auth.proxy, defaults to false
+;disable_signout_menu = false
+
+#################################### Anonymous Auth ##########################
+[auth.anonymous]
+# enable anonymous access
+;enabled = false
+
+# specify organization name that should be used for unauthenticated users
+;org_name = Main Org.
+
+# specify role for unauthenticated users
+;org_role = Viewer
+
+#################################### Github Auth ##########################
+[auth.github]
+;enabled = false
+;allow_sign_up = true
+;client_id = some_id
+;client_secret = some_secret
+;scopes = user:email,read:org
+;auth_url = https://github.com/login/oauth/authorize
+;token_url = https://github.com/login/oauth/access_token
+;api_url = https://api.github.com/user
+;team_ids =
+;allowed_organizations =
+
+#################################### Google Auth ##########################
+[auth.google]
+;enabled = false
+;allow_sign_up = true
+;client_id = some_client_id
+;client_secret = some_client_secret
+;scopes = https://www.googleapis.com/auth/userinfo.profile https://www.googleapis.com/auth/userinfo.email
+;auth_url = https://accounts.google.com/o/oauth2/auth
+;token_url = https://accounts.google.com/o/oauth2/token
+;api_url = https://www.googleapis.com/oauth2/v1/userinfo
+;allowed_domains =
+
+#################################### Generic OAuth ##########################
+[auth.generic_oauth]
+;enabled = false
+;name = OAuth
+;allow_sign_up = true
+;client_id = some_id
+;client_secret = some_secret
+;scopes = user:email,read:org
+;auth_url = https://foo.bar/login/oauth/authorize
+;token_url = https://foo.bar/login/oauth/access_token
+;api_url = https://foo.bar/user
+;team_ids =
+;allowed_organizations =
+
+#################################### Grafana.com Auth ####################
+[auth.grafananet]
+;enabled = false
+;allow_sign_up = true
+;client_id = some_id
+;client_secret = some_secret
+;scopes = user:email
+;allowed_organizations =
+
+#################################### Auth Proxy ##########################
+[auth.proxy]
+;enabled = false
+;header_name = X-WEBAUTH-USER
+;header_property = username
+;auto_sign_up = true
+;ldap_sync_ttl = 60
+;whitelist = 192.168.1.1, 192.168.2.1
+
+#################################### Basic Auth ##########################
+[auth.basic]
+;enabled = true
+
+#################################### Auth LDAP ##########################
+[auth.ldap]
+;enabled = false
+;config_file = /etc/grafana/ldap.toml
+;allow_sign_up = true
+
+#################################### SMTP / Emailing ##########################
+[smtp]
+;enabled = false
+;host = localhost:25
+;user =
+# If the password contains # or ; you have to wrap it with trippel quotes. Ex """#password;"""
+;password =
+;cert_file =
+;key_file =
+;skip_verify = false
+;from_address = admin@grafana.localhost
+;from_name = Grafana
+
+[emails]
+;welcome_email_on_sign_up = false
+
+#################################### Logging ##########################
+[log]
+# Either "console", "file", "syslog". Default is console and file
+# Use space to separate multiple modes, e.g. "console file"
+;mode = console file
+
+# Either "trace", "debug", "info", "warn", "error", "critical", default is "info"
+;level = info
+
+# optional settings to set different levels for specific loggers. Ex filters = sqlstore:debug
+;filters =
+
+
+# For "console" mode only
+[log.console]
+;level =
+
+# log line format, valid options are text, console and json
+;format = console
+
+# For "file" mode only
+[log.file]
+;level =
+
+# log line format, valid options are text, console and json
+;format = text
+
+# This enables automated log rotate(switch of following options), default is true
+;log_rotate = true
+
+# Max line number of single file, default is 1000000
+;max_lines = 1000000
+
+# Max size shift of single file, default is 28 means 1 << 28, 256MB
+;max_size_shift = 28
+
+# Segment log daily, default is true
+;daily_rotate = true
+
+# Expired days of log file(delete after max days), default is 7
+;max_days = 7
+
+[log.syslog]
+;level =
+
+# log line format, valid options are text, console and json
+;format = text
+
+# Syslog network type and address. This can be udp, tcp, or unix. If left blank, the default unix endpoints will be used.
+;network =
+;address =
+
+# Syslog facility. user, daemon and local0 through local7 are valid.
+;facility =
+
+# Syslog tag. By default, the process' argv[0] is used.
+;tag =
+
+
+#################################### AMQP Event Publisher ##########################
+[event_publisher]
+;enabled = false
+;rabbitmq_url = amqp://localhost/
+;exchange = grafana_events
+
+;#################################### Dashboard JSON files ##########################
+[dashboards.json]
+;enabled = false
+;path = /var/lib/grafana/dashboards
+
+#################################### Alerting ############################
+[alerting]
+# Disable alerting engine & UI features
+;enabled = true
+# Makes it possible to turn off alert rule execution but alerting UI is visible
+;execute_alerts = true
+
+#################################### Internal Grafana Metrics ##########################
+# Metrics available at HTTP API Url /api/metrics
+[metrics]
+# Disable / Enable internal metrics
+;enabled = true
+
+# Publish interval
+;interval_seconds = 10
+
+# Send internal metrics to Graphite
+[metrics.graphite]
+# Enable by setting the address setting (ex localhost:2003)
+;address =
+;prefix = prod.grafana.%(instance_name)s.
+
+#################################### Grafana.com integration ##########################
+# Url used to to import dashboards directly from Grafana.com
+[grafana_net]
+;url = https://grafana.com
+
+#################################### External image storage ##########################
+[external_image_storage]
+# Used for uploading images to public servers so they can be included in slack/email messages.
+# you can choose between (s3, webdav)
+;provider =
+
+[external_image_storage.s3]
+;bucket_url =
+;access_key =
+;secret_key =
+
+[external_image_storage.webdav]
+;url =
+;public_url =
+;username =
+;password =
--- /dev/null
+policy_module(cephmetrics, 1.0.0)
+
+require {
+ type collectd_t;
+ type ceph_t;
+ type ceph_var_run_t;
+ type ceph_var_lib_t;
+ type fixed_disk_device_t;
+ class unix_stream_socket connectto;
+ class dir read;
+ class file getattr;
+ class capability2 block_suspend;
+}
+
+#============= collectd_t ==============
+
+#!!!! This avc can be allowed using the boolean 'daemons_enable_cluster_mode'
+allow collectd_t ceph_t:unix_stream_socket connectto;
+allow collectd_t ceph_var_run_t:dir read;
+allow collectd_t ceph_var_lib_t:file getattr;
+allow collectd_t ceph_var_lib_t:lnk_file getattr;
+allow collectd_t ceph_var_lib_t:lnk_file read;
+allow collectd_t fixed_disk_device_t:blk_file getattr;
+allow collectd_t self:capability2 block_suspend;
+allow collectd_t var_log_t:dir { add_name write };
+allow collectd_t var_log_t:file create;
+corecmd_exec_shell(collectd_t)
+files_list_tmp(collectd_t)
+libs_exec_ldconfig(collectd_t)
+libs_manage_lib_dirs(collectd_t)
+libs_manage_lib_files(collectd_t)
+logging_write_generic_logs(collectd_t)
--- /dev/null
+{
+ "name":"Local",
+ "type":"graphite",
+ "url":"http://192.168.1.52",
+ "access":"proxy",
+ "basicAuth":false,
+ "isDefault":true
+}
--- /dev/null
+#!/usr/bin/env python
+
+from collectors.osd import OSDs
+from collectors.common import flatten_dict
+
+import time
+
+def main():
+ o = OSDs('ceph')
+ ctr = 0
+ while ctr < 30:
+
+ s = o.get_stats()
+ print(s)
+ print(flatten_dict(s))
+
+ time.sleep(1)
+ ctr += 1
+
+if __name__ == "__main__":
+ main()
--- /dev/null
+[tox]
+skipsdist = True
+
+[testenv:ansible-lint]
+install_command = pip install --upgrade {opts} {packages}
+deps=
+ ansible-lint
+commands=ansible-lint -x ANSIBLE0010,ANSIBLE0012,ANSIBLE0017 ansible/playbook.yml
+
+[testenv:ansible-syntax]
+install_command = pip install --upgrade {opts} {packages}
+deps=
+ ansible==2.2.3.0
+changedir=ansible
+commands=
+ ansible-playbook -i '127.0.0.1,' playbook.yml --syntax-check -vv
+
+[testenv:flake8]
+install_command = pip install --upgrade {opts} {packages}
+deps=
+ flake8
+commands=flake8 --select=F,E9 {posargs:*.py collectors tests}
projects / cephmetrics.git / commitdiff
