From: Paul Cuzner Date: Sun, 18 Jun 2017 22:08:23 +0000 (+1200) Subject: dashUpdater - refactoring and startup options added X-Git-Tag: v1.0~67^2~16 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=e20526d83ebc0475baa8a10a5dfbc207ef22aec2;p=cephmetrics.git dashUpdater - refactoring and startup options added Multiple changes - refactored code - added argparse to provide runtime options - adding logging module to provide more debug information - added checks to confirm grafana port is available before attempting to fetch dashboards - issue a return code back to the calling shell --- e20526d83ebc0475baa8a10a5dfbc207ef22aec2 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a7079d9 --- /dev/null +++ b/.gitignore @@ -0,0 +1,110 @@ +# 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 diff --git a/INSTALL.md b/INSTALL.md new file mode 100644 index 0000000..331dc64 --- /dev/null +++ b/INSTALL.md @@ -0,0 +1,128 @@ +# 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. the sample dashboards need to be added/edited to reflect the ceph cluster to +monitor +9.1 seed dashboards are provided in the dashboards/current directory +9.2 edit ```dashboard.yml``` with the shortnames of the OSD's and RGW's, plus +the dns domain name of the environment. +9.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. At-A-Glance Health History chart doesn't work as hoped due to interpolation over the +7 day timeline. For example a 4 gets averaged over a number of samples to fit on +the graph and appears as a '1'! +4. you can't easily export from the UI and then import programmitically with curl. +The export process puts additional metadata into the json, that is used by the +import UI - but this makes the templates fail to initialise if you try to use the +same file from a curl request. +5. The "at a glance" dashboard has some singlestat panels for host counts of OSD's +and RGW's. These values can be wrong - the query needs some work! +6. SELINUX may block the write_graphite plugin writing outbound on port 2003 + + + + diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..65c5ca8 --- /dev/null +++ b/LICENSE @@ -0,0 +1,165 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + 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. diff --git a/README b/README new file mode 100644 index 0000000..b6fd253 --- /dev/null +++ b/README @@ -0,0 +1,58 @@ +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" + + + Host "192.168.1.52" + Port "2003" + Protocol "tcp" + LogSendErrors true + Prefix "collectd." + StoreRates true + AlwaysAppendDS false + EscapeCharacter "_" + PreserveSeparator true + SeparateInstances true + + + +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/ + diff --git a/README.md b/README.md new file mode 100644 index 0000000..ae70787 --- /dev/null +++ b/README.md @@ -0,0 +1,2 @@ +# cephmetrics +ceph metric collectors with collectd integration diff --git a/TODO b/TODO new file mode 100644 index 0000000..cc52402 --- /dev/null +++ b/TODO @@ -0,0 +1,25 @@ + +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 diff --git a/ansible/README.md b/ansible/README.md new file mode 100644 index 0000000..b8f3137 --- /dev/null +++ b/ansible/README.md @@ -0,0 +1,61 @@ +# 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 +- 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 +TODO + +## Current Limitations + +- Only RHEL 7 hosts are supported +- Currently, metrics are only *displayed* for `osd` and `rgw` hosts. +- The `collectd` and `graphite-web` packages are sourced from [EPEL](https://fedoraproject.org/wiki/EPEL) and the `grafana` package is sourced from [grafana.com](https://grafana.com/) +- 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 + + ansible-playbook -v -i ./inventory diff --git a/ansible/ansible.cfg b/ansible/ansible.cfg new file mode 100644 index 0000000..40d9289 --- /dev/null +++ b/ansible/ansible.cfg @@ -0,0 +1,3 @@ +[defaults] +roles_path: ./roles/ +host_key_checking: False diff --git a/ansible/inventory.sample b/ansible/inventory.sample new file mode 100644 index 0000000..d3e8301 --- /dev/null +++ b/ansible/inventory.sample @@ -0,0 +1,18 @@ +[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 diff --git a/ansible/playbook.yml b/ansible/playbook.yml new file mode 100644 index 0000000..854341c --- /dev/null +++ b/ansible/playbook.yml @@ -0,0 +1,24 @@ +--- +- 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 diff --git a/ansible/roles/ceph-collectd/defaults/main.yml b/ansible/roles/ceph-collectd/defaults/main.yml new file mode 100644 index 0000000..2f9536f --- /dev/null +++ b/ansible/roles/ceph-collectd/defaults/main.yml @@ -0,0 +1,3 @@ +--- +containerized_deployment: false +cluster: ceph diff --git a/ansible/roles/ceph-collectd/files/cephmetrics.py b/ansible/roles/ceph-collectd/files/cephmetrics.py new file mode 120000 index 0000000..8de2567 --- /dev/null +++ b/ansible/roles/ceph-collectd/files/cephmetrics.py @@ -0,0 +1 @@ +../../../../cephmetrics.py \ No newline at end of file diff --git a/ansible/roles/ceph-collectd/files/collectors b/ansible/roles/ceph-collectd/files/collectors new file mode 120000 index 0000000..5efd446 --- /dev/null +++ b/ansible/roles/ceph-collectd/files/collectors @@ -0,0 +1 @@ +../../../../collectors \ No newline at end of file diff --git a/ansible/roles/ceph-collectd/files/etc b/ansible/roles/ceph-collectd/files/etc new file mode 120000 index 0000000..5221ea5 --- /dev/null +++ b/ansible/roles/ceph-collectd/files/etc @@ -0,0 +1 @@ +../../../../etc \ No newline at end of file diff --git a/ansible/roles/ceph-collectd/handlers/main.yml b/ansible/roles/ceph-collectd/handlers/main.yml new file mode 100644 index 0000000..bd989ee --- /dev/null +++ b/ansible/roles/ceph-collectd/handlers/main.yml @@ -0,0 +1,6 @@ +--- +- name: Restart collectd + service: + name: collectd + enabled: yes + state: restarted diff --git a/ansible/roles/ceph-collectd/tasks/install_collectd_plugins.yml b/ansible/roles/ceph-collectd/tasks/install_collectd_plugins.yml new file mode 100644 index 0000000..a9679e9 --- /dev/null +++ b/ansible/roles/ceph-collectd/tasks/install_collectd_plugins.yml @@ -0,0 +1,46 @@ +--- +- set_fact: + collectors_dir: /usr/lib64/collectd/python-plugins/collectors + +- name: Create collectors directory + file: + name: "{{ collectors_dir }}" + state: directory + +- name: Ship collector plugins + copy: + src: files/collectors/ + dest: "{{ collectors_dir }}" + notify: Restart collectd + +- name: Ship cephmetrics.py + copy: + src: files/cephmetrics.py + dest: /usr/lib64/collectd/python-plugins/ + notify: Restart collectd + +- name: Ship collectd.conf + copy: + src: files/etc/collectd.conf + dest: /etc/ + notify: Restart collectd + +- name: Ship /etc/collectd.d + copy: + src: files/etc/collectd.d + dest: /etc/ + notify: Restart collectd + +- name: Set hostname in write_graphite.conf + replace: + path: "/etc/collectd.d/write_graphite.conf" + regexp: 'Host ".*"' + replace: "Host \"{{ groups['ceph-grafana'][0] }}\"" + notify: Restart collectd + +- name: Set cluster name in cephmetrics.conf + replace: + path: /etc/collectd.d/cephmetrics.conf + regexp: 'ClusterName ".*"' + replace: 'ClusterName "{{ cluster }}"' + notify: Restart collectd diff --git a/ansible/roles/ceph-collectd/tasks/install_packages.yml b/ansible/roles/ceph-collectd/tasks/install_packages.yml new file mode 100644 index 0000000..6c0ed0d --- /dev/null +++ b/ansible/roles/ceph-collectd/tasks/install_packages.yml @@ -0,0 +1,11 @@ +--- +- name: Enable EPEL + yum: + name: "https://dl.fedoraproject.org/pub/epel/epel-release-latest-{{ ansible_distribution_major_version }}.noarch.rpm" + state: present + when: ansible_pkg_mgr == "yum" + +- name: Install collectd + package: + name: collectd + state: latest diff --git a/ansible/roles/ceph-collectd/tasks/main.yml b/ansible/roles/ceph-collectd/tasks/main.yml new file mode 100644 index 0000000..a1e2670 --- /dev/null +++ b/ansible/roles/ceph-collectd/tasks/main.yml @@ -0,0 +1,20 @@ +--- +- include: install_packages.yml + when: not containerized_deployment + tags: + - packages + +- include: install_collectd_plugins.yml + when: not containerized_deployment + tags: + - collectors + +- include: selinux.yml + when: not containerized_deployment + tags: + - selinux + +- include: start_collectd.yml + when: not containerized_deployment + tags: + - services diff --git a/ansible/roles/ceph-collectd/tasks/selinux.yml b/ansible/roles/ceph-collectd/tasks/selinux.yml new file mode 100644 index 0000000..753232c --- /dev/null +++ b/ansible/roles/ceph-collectd/tasks/selinux.yml @@ -0,0 +1,7 @@ +--- +- name: Enable collectd_tcp_network_connect SELinux boolean + seboolean: + name: collectd_tcp_network_connect + state: yes + persistent: yes + when: ansible_selinux.status is defined and ansible_selinux.status == 'enabled' diff --git a/ansible/roles/ceph-collectd/tasks/start_collectd.yml b/ansible/roles/ceph-collectd/tasks/start_collectd.yml new file mode 100644 index 0000000..ec4d7c4 --- /dev/null +++ b/ansible/roles/ceph-collectd/tasks/start_collectd.yml @@ -0,0 +1,6 @@ +--- +- name: Start collectd + service: + name: collectd + enabled: yes + state: started diff --git a/ansible/roles/ceph-grafana/defaults/main.yml b/ansible/roles/ceph-grafana/defaults/main.yml new file mode 100644 index 0000000..4ed8704 --- /dev/null +++ b/ansible/roles/ceph-grafana/defaults/main.yml @@ -0,0 +1,9 @@ +--- +containerized_deployment: false +graphite: + port: "{{ graphite_port | default('8080') }}" + user: admin + password: admin + grafana_name: Local +# The firewalld zone that carbon and grafana will use +firewalld_zone: internal diff --git a/ansible/roles/ceph-grafana/files/dashUpdater.py b/ansible/roles/ceph-grafana/files/dashUpdater.py new file mode 120000 index 0000000..a7871c4 --- /dev/null +++ b/ansible/roles/ceph-grafana/files/dashUpdater.py @@ -0,0 +1 @@ +../../../../dashUpdater.py \ No newline at end of file diff --git a/ansible/roles/ceph-grafana/files/dashboards b/ansible/roles/ceph-grafana/files/dashboards new file mode 120000 index 0000000..bf20664 --- /dev/null +++ b/ansible/roles/ceph-grafana/files/dashboards @@ -0,0 +1 @@ +../../../../dashboards/current \ No newline at end of file diff --git a/ansible/roles/ceph-grafana/handlers/main.yml b/ansible/roles/ceph-grafana/handlers/main.yml new file mode 100644 index 0000000..7aa2c61 --- /dev/null +++ b/ansible/roles/ceph-grafana/handlers/main.yml @@ -0,0 +1,19 @@ +--- +- name: Restart Grafana + service: + name: grafana-server + state: restarted + enabled: true + +- name: Restart graphite-web + service: + # graphite-web is served by httpd + name: httpd + state: restarted + enabled: true + +- name: Restart carbon-cache + service: + name: carbon-cache + state: restarted + enabled: true diff --git a/ansible/roles/ceph-grafana/tasks/configure_carbon.yml b/ansible/roles/ceph-grafana/tasks/configure_carbon.yml new file mode 100644 index 0000000..0a52ac7 --- /dev/null +++ b/ansible/roles/ceph-grafana/tasks/configure_carbon.yml @@ -0,0 +1,14 @@ +--- +- name: Configure retention for collectd stats + blockinfile: + path: /etc/carbon/storage-schemas.conf + # NOTE: Retention settings are applied to metrics as they are *created*. If + # these settings are changed after-the-fact, it's necessary to either + # delete the whisper files (!) or run whisper-resize on them all. + block: | + [collectd] + pattern = ^collectd\. + retentions = 1s:7d,1m:30d,15m:5y + # This must be above other declarations in the file + insertbefore: "BOF" + notify: Restart carbon-cache diff --git a/ansible/roles/ceph-grafana/tasks/configure_firewall.yml b/ansible/roles/ceph-grafana/tasks/configure_firewall.yml new file mode 100644 index 0000000..09845ff --- /dev/null +++ b/ansible/roles/ceph-grafana/tasks/configure_firewall.yml @@ -0,0 +1,16 @@ +--- +- name: Check firewalld status + shell: "systemctl show firewalld | grep UnitFileState" + register: firewalld_status + +- 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" diff --git a/ansible/roles/ceph-grafana/tasks/configure_grafana.yml b/ansible/roles/ceph-grafana/tasks/configure_grafana.yml new file mode 100644 index 0000000..72cb91a --- /dev/null +++ b/ansible/roles/ceph-grafana/tasks/configure_grafana.yml @@ -0,0 +1,126 @@ +--- +- name: Start Grafana + service: + name: grafana-server + state: started + enabled: true + +- set_fact: + grafana_data_source: > + { + "name":"{{ graphite.grafana_name }}", + "type":"graphite", + "url":"http://localhost:{{ graphite.port }}", + "access":"proxy", + "basicAuth":false, + "isDefault":true + } + +- name: Add data source + uri: + url: http://localhost:3000/api/datasources + method: POST + user: "{{ graphite.user }}" + password: "{{ graphite.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/{{ graphite.grafana_name }}" + method: GET + user: "{{ graphite.user }}" + password: "{{ graphite.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: "{{ graphite.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: Set domain in grafana.ini + lineinfile: + path: /etc/grafana/grafana.ini + regexp: "^domain = .*" + insertafter: "^;domain = .*" + line: "domain = {{ ansible_fqdn }}" + tags: [ini] + notify: Restart Grafana + +- name: Set root_url in grafana.ini + lineinfile: + path: /etc/grafana/grafana.ini + regexp: "^root_url = .*" + insertafter: "^;root_url = .*" + line: "root_url = %(protocol)s://%(domain)s:3000" + tags: [ini] + notify: Restart Grafana + +- name: Download Vonage Status Panel + get_url: + url: https://grafana.com/api/plugins/vonage-status-panel/versions/1.0.4/download + dest: /tmp/vonage.zip + +- name: Create Grafana plugins directory + file: + name: /var/lib/grafana/plugins + state: directory + +- set_fact: + vonage_plugin_path: /var/lib/grafana/plugins/Vonage-Grafana_Status_panel + +- stat: + path: "{{ vonage_plugin_path }}" + register: vonage_plugin + +- name: Unzip Vonage Status Panel + unarchive: + src: /tmp/vonage.zip + remote_src: true + dest: /var/lib/grafana/plugins/ + when: vonage_plugin.stat.exists is defined and not vonage_plugin.stat.exists + +- name: Move Vonage Status Panel into place + shell: "mv -f {{ vonage_plugin_path }}* {{ vonage_plugin_path }}" + when: vonage_plugin.stat.exists is defined and not vonage_plugin.stat.exists + notify: Restart Grafana + +- name: Ship dashboard templates + copy: + src: files/dashboards + dest: /tmp/ + +- name: Ship dashUpdater.py + copy: + src: files/dashUpdater.py + dest: /tmp/dashUpdater.py + +- name: Set correct path in dashUpdater.py + replace: + path: /tmp/dashUpdater.py + regexp: "^dashboard_dir = '.*'" + replace: "dashboard_dir = 'dashboards'" + +- name: Write dashboard.yml + template: + src: dashboard.yml + dest: /tmp/dashboard.yml + +- name: Push dashboards to Grafana + command: python dashUpdater.py + args: + chdir: /tmp diff --git a/ansible/roles/ceph-grafana/tasks/configure_graphite.yml b/ansible/roles/ceph-grafana/tasks/configure_graphite.yml new file mode 100644 index 0000000..8627b5c --- /dev/null +++ b/ansible/roles/ceph-grafana/tasks/configure_graphite.yml @@ -0,0 +1,42 @@ +--- +- name: Create Graphite DB tables + command: /usr/bin/graphite-manage syncdb --noinput + become_user: apache + +- name: Build Graphite index + command: /usr/bin/graphite-build-index + become_user: apache + +- 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.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.port }}" + insertbefore: "^$" + replace: "" + 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: '' + state: present + notify: Restart graphite-web diff --git a/ansible/roles/ceph-grafana/tasks/install_packages.yml b/ansible/roles/ceph-grafana/tasks/install_packages.yml new file mode 100644 index 0000000..fda5edc --- /dev/null +++ b/ansible/roles/ceph-grafana/tasks/install_packages.yml @@ -0,0 +1,20 @@ +--- +- yum: + name: "https://dl.fedoraproject.org/pub/epel/epel-release-latest-{{ ansible_distribution_major_version }}.noarch.rpm" + state: present + when: ansible_pkg_mgr == "yum" + +- name: Add Grafana repo + template: + src: grafana.repo + dest: /etc/yum.repos.d/grafana.repo + when: ansible_pkg_mgr == "yum" + +- name: Install packages + package: + name: "{{ item }}" + state: latest + with_items: + - graphite-web + - python-carbon + - grafana diff --git a/ansible/roles/ceph-grafana/tasks/main.yml b/ansible/roles/ceph-grafana/tasks/main.yml new file mode 100644 index 0000000..387429e --- /dev/null +++ b/ansible/roles/ceph-grafana/tasks/main.yml @@ -0,0 +1,38 @@ +--- +- include: install_packages.yml + when: not containerized_deployment + tags: + - packages + +- 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: 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 + +- include: start_services.yml + when: not containerized_deployment + tags: + - services + +- include: configure_firewall.yml + tags: + - firewall diff --git a/ansible/roles/ceph-grafana/tasks/start_services.yml b/ansible/roles/ceph-grafana/tasks/start_services.yml new file mode 100644 index 0000000..6e7acdf --- /dev/null +++ b/ansible/roles/ceph-grafana/tasks/start_services.yml @@ -0,0 +1,11 @@ +--- +- name: Enable and start services + service: + name: "{{ item }}" + state: started + enabled: true + with_items: + - carbon-cache + # graphite-web is served by httpd + - httpd + - grafana-server diff --git a/ansible/roles/ceph-grafana/templates/dashboard.yml b/ansible/roles/ceph-grafana/templates/dashboard.yml new file mode 100644 index 0000000..105f359 --- /dev/null +++ b/ansible/roles/ceph-grafana/templates/dashboard.yml @@ -0,0 +1,19 @@ +--- +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: + - ceph-at-a-glance + - ceph-backend-storage + - ceph-frontend + - ceph-rados + - ceph-rgw-workload + - disk-busy-by-server + - iops-by-server + - latency-by-server + - network-usage-by-node + - osd-node-detail +_credentials: + user: admin + password: admin +_grafana_port: 3000 diff --git a/ansible/roles/ceph-grafana/templates/grafana.repo b/ansible/roles/ceph-grafana/templates/grafana.repo new file mode 100644 index 0000000..1ba7fb6 --- /dev/null +++ b/ansible/roles/ceph-grafana/templates/grafana.repo @@ -0,0 +1,9 @@ +[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 diff --git a/cephmetrics.py b/cephmetrics.py new file mode 100644 index 0000000..49bb3f6 --- /dev/null +++ b/cephmetrics.py @@ -0,0 +1,130 @@ +#!/usr/bin/env python +import os +import glob +import collectd + +from collectors.mon import Mon +from collectors.rgw import RGW +from collectors.osd import OSDs +from collectors.common import flatten_dict, get_hostname, freadlines + +__author__ = 'Paul Cuzner' + +PLUGIN_NAME = 'cephmetrics' + + +class Ceph(object): + def __init__(self): + self.cluster_name = None + self.host_name = get_hostname() + + self.mon_socket = None + self.rgw_socket = None + + self.mon = None + self.rgw = None + self.osd = 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 = '/var/run/ceph/{}-mon.{}.asok'.format(self.cluster_name, + self.host_name) + if os.path.exists(mon_socket): + self.mon_socket = mon_socket + self.mon = Mon(self.cluster_name, + admin_socket=mon_socket) + + rgw_socket_list = glob.glob('/var/run/ceph/{}-client.rgw.{}.' + '*.asok'.format(self.cluster_name, + self.host_name)) + if rgw_socket_list: + rgw_socket = rgw_socket_list[0] + self.rgw = RGW(self.cluster_name, + admin_socket=rgw_socket) + + osd_socket_list = glob.glob('/var/run/ceph/{}-osd.*' + '.asok'.format(self.cluster_name)) + mounted = freadlines('/proc/mounts') + osds_mounted = [mnt for mnt in mounted + if mnt.split()[1].startswith('/var/lib/ceph')] + if osd_socket_list or osds_mounted: + self.osd = OSDs(self.cluster_name) + + collectd.info("{}: Roles detected - mon:{} " + "osd:{} rgw:{}".format(__name__, + isinstance(self.mon, Mon), + isinstance(self.osd, OSDs), + isinstance(self.rgw, RGW))) + + +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 + attr_type = role_metrics[attr_name][1] # gauge / derive etc + 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): + + global CEPH + module_parms = {node.key: node.values[0] for node in conf.children} + + 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 + + CEPH.probe() + + else: + collectd.error("ClusterName is required") + + +def read_callback(): + + if CEPH.mon: + mon_stats = CEPH.mon.get_stats() + write_stats(Mon.all_metrics, mon_stats) + + if CEPH.rgw: + rgw_stats = CEPH.rgw.get_stats() + write_stats(RGW.all_metrics, rgw_stats) + + if CEPH.osd: + osd_node_stats = CEPH.osd.get_stats() + write_stats(OSDs.all_metrics, osd_node_stats) + + +if __name__ == '__main__': + # run interactively or maybe test the code + collectd.info("In main for some reason !") + pass + +else: + + CEPH = Ceph() + + collectd.register_config(configure_callback) + collectd.register_read(read_callback) diff --git a/collectors/__init__.py b/collectors/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/collectors/base.py b/collectors/base.py new file mode 100644 index 0000000..2c4590b --- /dev/null +++ b/collectors/base.py @@ -0,0 +1,21 @@ +#!/usr/bin/env python +from ceph_daemon import admin_socket +import json + +class BaseCollector(object): + + def __init__(self, cluster_name, admin_socket=None): + self.cluster_name = cluster_name + self.admin_socket = admin_socket + + def _admin_socket(self, cmds=None): + if not cmds: + cmds = ['perf', 'dump'] + + response = admin_socket(self.admin_socket, cmds, + format='json') + return json.loads(response) + + def get_stats(self): + + return {} diff --git a/collectors/common.py b/collectors/common.py new file mode 100644 index 0000000..60a9406 --- /dev/null +++ b/collectors/common.py @@ -0,0 +1,199 @@ +#!/usr/bin/env python + + +import socket +from os import statvfs + + +def get_hostname(): + return socket.gethostname().split('.')[0] + + +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 + """ + + with open(file_name, 'r') as f: + setting = f.read().rstrip() + return setting + + +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 + """ + + with open(file_name, 'r') as f: + data = f.readlines() + return data + + +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) / 1024 ** 2) / sample_interval + self.w_bytes_per_sec = (float( + self._sectors_written * IOstat.sector_size) / 1024 ** 2) / 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"), + "fs_size": ("fs_size", "gauge"), + "fs_used": ("fs_used", "gauge"), + "osd_id": ("osd_id", "gauge") + } + + def _get_size(self): + return int(fread("/sys/block/{}/size".format(self._name))) * 512 + + def _get_rota(self): + return int(fread("/sys/block/{}/queue/rotational".format(self._name))) + + def _get_fssize(self): + s = statvfs("{}/whoami".format(self._path_name)) + return s.f_blocks * s.f_bsize, s.f_bfree * s.f_bsize + + def refresh(self): + self.fs_size, self.fs_used = self._get_fssize() diff --git a/collectors/mon.py b/collectors/mon.py new file mode 100644 index 0000000..f790d0d --- /dev/null +++ b/collectors/mon.py @@ -0,0 +1,157 @@ +#!/usr/bin/env python + +import rados +import json + +from collectors.base import BaseCollector +from collectors.common import add_dicts, merge_dicts + + +class Mon(BaseCollector): + + health = { + "HEALTH_OK": 0, + "HEALTH_WARN": 4, + "HEALTH_ERR": 8 + } + + # 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_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") + } + + all_metrics = merge_dicts(pool_recovery_metrics, pool_client_metrics) + all_metrics = merge_dicts(all_metrics, cluster_metrics) + + def _mon_command(self, cmd_request): + """ Issue a command to the monitor """ + + buf_s = '{}' + conf_file = "/etc/ceph/{}.conf".format(self.cluster_name) + + 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'') + + return json.loads(buf_s) + + def _mon_health(self): + + cluster_data = self._admin_socket().get('cluster') + health_text = self._mon_command("health").get('overall_status', + 'UNKNOWN') + health_num = Mon.health.get(health_text, 16) + + cluster = {Mon.cluster_metrics[k][0]: cluster_data[k] + for k in cluster_data} + + cluster['health'] = health_num + + return cluster + + @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_stats(self): + """ + method associated with the plugin callback to gather the metrics + :return: + """ + + pool_stats = self._get_pool_stats() + cluster_state = self._mon_health() + all_stats = merge_dicts(cluster_state, {"pools": pool_stats}) + + return {"mon": all_stats} + diff --git a/collectors/osd.py b/collectors/osd.py new file mode 100644 index 0000000..eb16937 --- /dev/null +++ b/collectors/osd.py @@ -0,0 +1,106 @@ +#!/usr/bin/env python + +import time + +from collectors.base import BaseCollector +from collectors.common import (todict, freadlines, merge_dicts, + IOstat, Disk) + +__author__ = "Paul Cuzner" + + +class OSDs(BaseCollector): + + all_metrics = merge_dicts(Disk.metrics, IOstat.metrics) + + def __init__(self, cluster_name): + BaseCollector.__init__(self, cluster_name) + self.timestamp = int(time.time()) + + self.osd = {} # dict of disk objects, each disk contains osd_id + + 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 _dev_to_osd(self): + """ + Look at the system to determine which disks are acting as OSD's + """ + + 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): + osd_id = path_name.split('-')[-1] + + device = filter(lambda ch: ch.isalpha(), + dev_path.split('/')[-1]) + + if device not in self.osd: + disk = Disk() + disk._name = device + disk._path_name = path_name + disk.osd_id = osd_id + disk.rotational = disk._get_rota() + disk.perf = IOstat() + disk.disk_size = disk._get_size() + disk.refresh() + self.osd[device] = disk + + def _stats_lookup(self): + """ + Grab the disk stats from /proc + """ + + now = int(time.time()) + interval = now - self.timestamp + self.timestamp = now + + for perf_entry in freadlines('/proc/diskstats'): + + field = perf_entry.split() + dev_name = field[2] + + if dev_name in self.osd.keys(): + new_stats = field[3:] + device = self.osd[dev_name] + 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) + device.refresh() + + def dump(self): + + osd_info = {} + + for dev in sorted(self.osd): + device_obj = self.osd[dev] + osd_info[dev] = todict(device_obj) + + return {"osd": osd_info} + + def get_stats(self): + + self._dev_to_osd() + self._stats_lookup() + + return self.dump() diff --git a/collectors/rgw.py b/collectors/rgw.py new file mode 100644 index 0000000..201ab97 --- /dev/null +++ b/collectors/rgw.py @@ -0,0 +1,66 @@ +#!/usr/bin/env python + +from collectors.base import BaseCollector +from collectors.common import get_hostname, merge_dicts + +__author__ = "paul.cuzner@redhat.com" + + +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, cluster_name, admin_socket): + BaseCollector.__init__(self, cluster_name, admin_socket) + 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): + + raw_stats = self._get_rgw_data() + + stats = self._filter(raw_stats) + + return {"rgw": stats} diff --git a/dashUpdater.py b/dashUpdater.py new file mode 100644 index 0000000..8c3eaf5 --- /dev/null +++ b/dashUpdater.py @@ -0,0 +1,316 @@ +#!/usr/bin/env python2 + +import os +import sys +import logging +import json +import yaml +from requests import get, post +import argparse +import socket + +__author__ = 'Paul Cuzner' +__version__ = '2.0' + +HEADERS = {"Accept": "application/json", + "Content-Type": "application/json" + } + +dashboard_dir = os.path.join(os.getcwd(), + 'dashboards/current') + +# 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('-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.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_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) + 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'] = False + + # '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 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 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('_')} + else: + logger.error("Config file doesn't contain dashboards! Unable " + "to continue") + return 12 + + dashboards_updated = 0 + logger.debug("Templates to update: {}".format(vars_to_update)) + + for dashname in config.dashboards: + logger.info("\nProcessing dashboard {}".format(dashname)) + + if opts.mode == 'update': + http_rc, dashjson = get_dashboard(dashname) + if http_rc == 404: + dashjson = load_dashboard(dashname) + + if not dashjson: + logger.warning("- sample not available, skipping") + rc = max(rc, 4) + continue + + logger.info("- dashboard retrieved") + elif opts.mode == 'refresh': + dashjson = load_dashboard(dashname) + if not dashjson: + logger.warning("- sample not available, skipping") + rc = max(rc, 4) + continue + + 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 + 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) diff --git a/dashboard.yml b/dashboard.yml new file mode 100644 index 0000000..ab823a0 --- /dev/null +++ b/dashboard.yml @@ -0,0 +1,36 @@ +--- +########################################################## +# Change these settings to reflect your ceph environment # +########################################################## +osd_servers: + - ceph-1 + - ceph-2 + - ceph-3 + +#rgw_servers: +# - obj-rgw-1 + +domain: test.lab + +########################################################################### +# This section defines the internal variables (denoted by the '_' prefix) # +# that govern how dashUpdater.py runs. Normally you'd leave these alone # +########################################################################### +_dashboards: + - ceph-at-a-glance + - ceph-backend-storage + - ceph-frontend + - ceph-rados + - ceph-rgw-workload + - disk-busy-by-server + - iops-by-server + - latency-by-server + - network-usage-by-node + - osd-node-detail + +_credentials: + user: admin + password: admin + +_grafana_port: 3000 + diff --git a/dashboards/archive/Ceph_dashboard-2017-05-19.json b/dashboards/archive/Ceph_dashboard-2017-05-19.json new file mode 100644 index 0000000..f8099f0 --- /dev/null +++ b/dashboards/archive/Ceph_dashboard-2017-05-19.json @@ -0,0 +1,788 @@ +{ + "__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 diff --git a/dashboards/archive/Ceph_dashboard-2017-05-24.json b/dashboards/archive/Ceph_dashboard-2017-05-24.json new file mode 100644 index 0000000..7ea21a7 --- /dev/null +++ b/dashboards/archive/Ceph_dashboard-2017-05-24.json @@ -0,0 +1,2413 @@ +{ + "__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 diff --git a/dashboards/archive/Ceph_dashboard-2017-05-25.json b/dashboards/archive/Ceph_dashboard-2017-05-25.json new file mode 100644 index 0000000..915b0e1 --- /dev/null +++ b/dashboards/archive/Ceph_dashboard-2017-05-25.json @@ -0,0 +1,2689 @@ +{ + "__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 diff --git a/dashboards/archive/Ceph_dashboard-2017-05-26.json b/dashboards/archive/Ceph_dashboard-2017-05-26.json new file mode 100644 index 0000000..e6cb476 --- /dev/null +++ b/dashboards/archive/Ceph_dashboard-2017-05-26.json @@ -0,0 +1,2792 @@ +{ + "__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 diff --git a/dashboards/archive/Ceph_dashboard-2017-05-29.json b/dashboards/archive/Ceph_dashboard-2017-05-29.json new file mode 100644 index 0000000..9765ed9 --- /dev/null +++ b/dashboards/archive/Ceph_dashboard-2017-05-29.json @@ -0,0 +1,3669 @@ +{ + "__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 diff --git a/dashboards/archive/Ceph_dashboard-2017-05-31.json b/dashboards/archive/Ceph_dashboard-2017-05-31.json new file mode 100644 index 0000000..4fbc5e6 --- /dev/null +++ b/dashboards/archive/Ceph_dashboard-2017-05-31.json @@ -0,0 +1,3757 @@ +{ + "__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 diff --git a/dashboards/archive/Disk Busy by Server-2017-05-31.json b/dashboards/archive/Disk Busy by Server-2017-05-31.json new file mode 100644 index 0000000..fdc6468 --- /dev/null +++ b/dashboards/archive/Disk Busy by Server-2017-05-31.json @@ -0,0 +1,404 @@ +{ + "__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 diff --git a/dashboards/archive/IOPS by Server-2017-05-31.json b/dashboards/archive/IOPS by Server-2017-05-31.json new file mode 100644 index 0000000..02de4d6 --- /dev/null +++ b/dashboards/archive/IOPS by Server-2017-05-31.json @@ -0,0 +1,363 @@ +{ + "__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 diff --git a/dashboards/archive/Latency by Server-2017-05-31.json b/dashboards/archive/Latency by Server-2017-05-31.json new file mode 100644 index 0000000..b5465dd --- /dev/null +++ b/dashboards/archive/Latency by Server-2017-05-31.json @@ -0,0 +1,384 @@ +{ + "__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 diff --git a/dashboards/current/Dashboard Relationships.jpg b/dashboards/current/Dashboard Relationships.jpg new file mode 100644 index 0000000..e269d4b Binary files /dev/null and b/dashboards/current/Dashboard Relationships.jpg differ diff --git a/dashboards/current/ceph-at-a-glance.json b/dashboards/current/ceph-at-a-glance.json new file mode 100644 index 0000000..457f987 --- /dev/null +++ b/dashboards/current/ceph-at-a-glance.json @@ -0,0 +1 @@ +{"meta":{"type":"db","canSave":true,"canEdit":true,"canStar":true,"slug":"ceph-at-a-glance","expires":"0001-01-01T00:00:00Z","created":"2017-06-07T20:56:52Z","updated":"2017-06-09T23:23:36Z","updatedBy":"admin","createdBy":"admin","version":21},"dashboard":{"annotations":{"list":[]},"editable":false,"gnetId":null,"graphTooltip":0,"hideControls":true,"id":1,"links":[{"asDropdown":true,"icon":"external link","includeVars":true,"keepTime":true,"tags":["overview"],"targetBlank":true,"title":"Shortcuts","type":"dashboards"}],"refresh":"10s","rows":[{"collapse":false,"height":96,"panels":[{"cacheTimeout":null,"colorBackground":false,"colorValue":true,"colors":["rgba(245, 122, 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":"50px","id":66,"interval":null,"links":[{"dashUri":"db/ceph-frontend","dashboard":"Ceph - Frontend","includeVars":true,"keepTime":true,"targetBlank":true,"title":"Ceph - Frontend","type":"dashboard"}],"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":""}],"thresholds":"1","title":"","transparent":true,"type":"singlestat","valueFontSize":"40%","valueMaps":[{"op":"=","text":"Pools","value":"null"}],"valueName":"current"},{"cacheTimeout":null,"colorBackground":false,"colorValue":true,"colors":["rgba(198, 32, 199, 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":"50px","id":67,"interval":null,"links":[{"dashUri":"db/ceph-backend-storage","dashboard":"Ceph Backend Storage","includeVars":true,"keepTime":true,"targetBlank":true,"title":"Ceph Backend Storage","type":"dashboard"}],"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":""}],"thresholds":"1","title":"","transparent":true,"type":"singlestat","valueFontSize":"40%","valueMaps":[{"op":"=","text":"Backend","value":"null"}],"valueName":"current"},{"cacheTimeout":null,"colorBackground":false,"colorValue":true,"colors":["rgba(50, 172, 45, 0.97)","rgba(237, 129, 40, 0.89)","rgba(245, 122, 54, 0.9)"],"datasource":null,"format":"none","gauge":{"maxValue":100,"minValue":0,"show":false,"thresholdLabels":false,"thresholdMarkers":true},"height":"50px","id":68,"interval":null,"links":[{"dashUri":"db/ceph-rgw-workload","dashboard":"Ceph - RGW Workload","includeVars":true,"keepTime":true,"targetBlank":true,"title":"Ceph - RGW Workload","type":"dashboard"}],"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":""}],"thresholds":"1","title":"","transparent":true,"type":"singlestat","valueFontSize":"40%","valueMaps":[{"op":"=","text":"S3/Swift","value":"null"}],"valueName":"current"},{"cacheTimeout":null,"colorBackground":false,"colorValue":true,"colors":["rgba(16, 53, 224, 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":"50px","id":69,"interval":null,"links":[{"dashUri":"db/network-usage-by-node","dashboard":"Network Usage by Node","includeVars":true,"keepTime":true,"targetBlank":true,"title":"Network Usage by Node","type":"dashboard"}],"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":""}],"thresholds":"1","title":"","transparent":true,"type":"singlestat","valueFontSize":"40%","valueMaps":[{"op":"=","text":"Network","value":"null"}],"valueName":"current"},{"cacheTimeout":null,"colorBackground":false,"colorValue":true,"colors":["rgba(35, 155, 201, 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":"50px","id":70,"interval":null,"links":[{"dashUri":"db/ceph-rados","dashboard":"Ceph - RADOS","includeVars":true,"keepTime":true,"targetBlank":true,"title":"Ceph - RADOS","type":"dashboard"}],"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":""}],"thresholds":"1","title":"","transparent":true,"type":"singlestat","valueFontSize":"40%","valueMaps":[{"op":"=","text":"RADOS","value":"null"}],"valueName":"current"}],"repeat":null,"repeatIteration":null,"repeatRowId":null,"showTitle":false,"title":"Dashboard Row","titleSize":"h6"},{"collapse":false,"height":243,"panels":[{"cacheTimeout":null,"colorBackground":true,"colorValue":false,"colors":["rgba(0,128,0, 0.97)","rgba(237, 129, 40, 0.89)","rgba(245, 54, 54, 0.9)"],"datasource":"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":"maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.health)","textEditor":true}],"thresholds":"1","title":"Health","type":"singlestat","valueFontSize":"50%","valueMaps":[{"op":"=","text":"OK","value":"0"},{"op":"=","text":"WARN","value":"4"},{"op":"=","text":"ERROR","value":"8"}],"valueName":"current"},{"aliasColors":{"Ceph Health":"#F9D9F9","Ceph Health (0:OK, 4:Warning,8:Error)":"#DEDAF7","collectd.obj-mon-1.storage.lab.cephmetrics.gauge.ceph.mon.health":"#DEDAF7"},"bars":false,"dashLength":10,"dashes":false,"datasource":null,"fill":1,"hideTimeOverride":true,"id":61,"legend":{"avg":false,"current":false,"max":false,"min":false,"show":false,"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":false,"steppedLine":true,"targets":[{"refId":"A","target":"alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.health), 'Ceph Health')","textEditor":true}],"thresholds":[{"colorMode":"ok","fill":true,"line":false,"op":"lt","value":3},{"colorMode":"warning","fill":true,"line":false,"op":"lt","value":7},{"colorMode":"critical","fill":true,"line":false,"op":"gt","value":7}],"timeFrom":"7d","timeShift":null,"title":"Health History - Last 7 days","tooltip":{"shared":true,"sort":1,"value_type":"individual"},"type":"graph","xaxis":{"buckets":null,"mode":"time","name":null,"show":true,"values":[]},"yaxes":[{"format":"short","label":"","logBase":1,"max":"14","min":"-1","show":false},{"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":"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":"maxSeries(collectd.*.$domain.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":null,"decimals":0,"format":"short","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":"countSeries(groupByNode(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.osd_id,1,\"sumSeries\"))","textEditor":true}],"thresholds":"","title":"OSD Hosts","type":"singlestat","valueFontSize":"80%","valueMaps":[{"op":"=","text":"N/A","value":"null"}],"valueName":"current"},{"clusterName":"OSD's","displayName":"OSD's","flipCard":false,"flipTime":5,"id":65,"links":[],"minSpan":1,"namePrefix":"","span":1,"targets":[{"aggregation":"Last","alias":"Total","display":false,"displayType":"Regular","refId":"A","target":"alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd), 'Total')","textEditor":true,"valueHandler":"Text Only"},{"aggregation":"Last","alias":"in","display":false,"displayType":"Regular","refId":"B","target":"alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd_in), \"in\")","textEditor":true,"valueHandler":"Text Only"},{"aggregation":"Last","alias":"up","display":false,"displayType":"Regular","refId":"C","target":"alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd_up), \"up\")","textEditor":true,"valueHandler":"Text Only"},{"aggregation":"Last","alias":"down","crit":"3","display":true,"displayType":"Regular","hide":false,"refId":"D","target":"alias(diffSeries(#B,#C), \"down\")","targetFull":"alias(diffSeries(alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd_in), \"in\"),alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_osd_up), \"up\")), \"down\")","textEditor":true,"valueHandler":"Threshold","warn":"1"}],"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":null,"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":null,"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":"maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_mds_in)","textEditor":true}],"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":"Local","format":"none","gauge":{"maxValue":100,"minValue":0,"show":false,"thresholdLabels":false,"thresholdMarkers":true},"id":58,"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":"maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_pool)","textEditor":true}],"thresholds":"","title":"Pools","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":null,"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":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":"maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_avail)","textEditor":true}],"thresholds":"","title":"Free Space","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","format":"bytes","gauge":{"maxValue":100,"minValue":0,"show":false,"thresholdLabels":false,"thresholdMarkers":true},"id":7,"interval":null,"links":[{"dashUri":"db/ceph-backend-storage","dashboard":"Ceph Backend Storage","includeVars":true,"keepTime":true,"targetBlank":true,"title":"Ceph Backend Storage","type":"dashboard"}],"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},"tableColumn":"","targets":[{"refId":"B","target":"sumSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.*.recovering_bytes_per_sec,-2,\"maxSeries\"))","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":"Local","decimals":0,"format":"short","gauge":{"maxValue":100,"minValue":0,"show":false,"thresholdLabels":false,"thresholdMarkers":true},"id":9,"interval":null,"links":[{"dashUri":"db/ceph-frontend","dashboard":"Ceph - Frontend","includeVars":true,"keepTime":true,"targetBlank":true,"title":"Ceph - Frontend","type":"dashboard"}],"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":[{"dsType":"influxdb","groupBy":[],"hide":false,"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":"sumSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.*.op_per_sec,-2,\"maxSeries\"))","textEditor":true}],"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":"Local","decimals":1,"format":"bytes","gauge":{"maxValue":100,"minValue":0,"show":false,"thresholdLabels":false,"thresholdMarkers":true},"id":23,"interval":null,"links":[{"dashUri":"db/ceph-frontend","dashboard":"Ceph - Frontend","includeVars":true,"keepTime":true,"targetBlank":true,"title":"Ceph - Frontend","type":"dashboard"}],"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":[{"dsType":"influxdb","groupBy":[],"hide":false,"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":"sumSeries(groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.*.bytes_sec,-2,\"maxSeries\"))","textEditor":true}],"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(0,128,0, 0.97)","rgba(237, 129, 40, 0.89)","rgba(245, 54, 54, 0.9)"],"datasource":null,"decimals":1,"format":"short","gauge":{"maxValue":100,"minValue":0,"show":false,"thresholdLabels":false,"thresholdMarkers":true},"id":37,"interval":null,"links":[{"dashUri":"db/disk-busy-by-server","dashboard":"Disk Busy by Server","includeVars":true,"keepTime":false,"targetBlank":true,"title":"Disk Busy by Server","type":"dashboard"}],"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.$osd_servers.$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(0,128,0, 0.97)","rgba(237, 129, 40, 0.89)","rgba(245, 54, 54, 0.9)"],"datasource":null,"decimals":1,"format":"short","gauge":{"maxValue":100,"minValue":0,"show":false,"thresholdLabels":false,"thresholdMarkers":true},"id":36,"interval":null,"links":[{"dashUri":"db/latency-by-server","dashboard":"Latency by Server","includeVars":true,"targetBlank":true,"title":"Latency by Server","type":"dashboard"}],"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.$osd_servers.$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(50, 172, 45, 0.97)","rgba(237, 129, 40, 0.89)","rgba(245, 54, 54, 0.9)"],"datasource":null,"decimals":0,"format":"short","gauge":{"maxValue":100,"minValue":0,"show":true,"thresholdLabels":false,"thresholdMarkers":true},"id":59,"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":"percentileOfSeries(groupByNode(collectd.$osd_servers.$domain.cpu.percent.{system,user,wait},1,\"sumSeries\"),$percentile)","textEditor":true}],"thresholds":"70,90","title":"OSD CPU Busy %","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":null,"decimals":0,"format":"short","gauge":{"maxValue":100,"minValue":0,"show":true,"thresholdLabels":false,"thresholdMarkers":true},"id":60,"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},"tableColumn":"","targets":[{"refId":"B","target":"percentileOfSeries(groupByNode(collectd.$rgw_servers.$domain.cpu.percent.{system,user,wait},1,\"sumSeries\"),$percentile)","textEditor":true}],"thresholds":"70,90","title":"RGW CPU Busy %","type":"singlestat","valueFontSize":"80%","valueMaps":[{"op":"=","text":"N/A","value":"null"}],"valueName":"current"}],"repeat":null,"repeatIteration":null,"repeatRowId":null,"showTitle":true,"title":"At a Glance","titleSize":"h6"}],"schemaVersion":14,"style":"dark","tags":["overview"],"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":"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":{"selected":true,"text":"95","value":"95"},"hide":0,"includeAll":false,"label":"Percentile","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":"ceph-1","value":"ceph-1"},{"selected":false,"text":"ceph-2","value":"ceph-2"},{"selected":false,"text":"ceph-3","value":"ceph-3"}],"query":"ceph-1,ceph-2,ceph-3","type":"custom"},{"allValue":null,"current":{"text":"obj-rgw-1","value":"obj-rgw-1"},"hide":2,"includeAll":false,"label":null,"multi":true,"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":"Ceph - At A Glance","version":21}} \ No newline at end of file diff --git a/dashboards/current/ceph-backend-storage.json b/dashboards/current/ceph-backend-storage.json new file mode 100644 index 0000000..918929f --- /dev/null +++ b/dashboards/current/ceph-backend-storage.json @@ -0,0 +1 @@ +{"meta":{"type":"db","canSave":true,"canEdit":true,"canStar":true,"slug":"ceph-backend-storage","expires":"0001-01-01T00:00:00Z","created":"2017-06-07T20:56:52Z","updated":"2017-06-10T06:52:19Z","updatedBy":"admin","createdBy":"admin","version":5},"dashboard":{"annotations":{"list":[]},"editable":true,"gnetId":null,"graphTooltip":0,"hideControls":false,"id":2,"links":[{"asDropdown":true,"icon":"external link","includeVars":true,"keepTime":true,"tags":["overview"],"targetBlank":true,"title":"Shortcuts","type":"dashboards"}],"refresh":"10s","rows":[{"collapse":false,"height":250,"panels":[{"cards":{"cardPadding":null,"cardRound":null},"color":{"cardColor":"#b4ff00","colorScale":"sqrt","colorScheme":"interpolateOranges","exponent":0.5,"mode":"spectrum"},"dataFormat":"timeseries","heatmap":{},"highlightCards":true,"id":53,"links":[],"minSpan":10,"span":10,"targets":[{"refId":"A","target":"collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.util","textEditor":true}],"title":"OSD Drive Utilisation Heatmap","tooltip":{"show":true,"showHistogram":false},"type":"heatmap","xAxis":{"show":true},"xBucketNumber":180,"xBucketSize":"","yAxis":{"decimals":null,"format":"short","logBase":1,"max":"100","min":"0","show":true,"splitFactor":null},"yBucketNumber":null,"yBucketSize":5},{"columns":[{"text":"Current","value":"current"}],"description":"","fontSize":"100%","id":55,"links":[],"minSpan":2,"pageSize":null,"scroll":true,"showHeader":true,"sort":{"col":1,"desc":false},"span":2,"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.*.osd_id,1,-2)","textEditor":true}],"title":"","transform":"timeseries_aggregations","type":"table"}],"repeat":null,"repeatIteration":null,"repeatRowId":null,"showTitle":true,"title":"OSD Heatmap over time","titleSize":"h6"},{"collapse":false,"height":"300","panels":[{"aliasColors":{},"bars":false,"dashLength":10,"dashes":false,"datasource":null,"fill":3,"id":54,"legend":{"avg":false,"current":false,"max":false,"min":false,"show":false,"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":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}]},{"aliasColors":{},"bars":false,"dashLength":10,"dashes":false,"datasource":"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":6,"nullPointMode":"null","percentage":false,"pointradius":5,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"span":6,"stack":true,"steppedLine":false,"targets":[{"refId":"A","target":"alias(sumSeries(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.r_bytes_per_sec), \"Read Throughput\")","textEditor":true},{"refId":"B","target":"alias(sumSeries(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.w_bytes_per_sec), \"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":"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":6,"nullPointMode":"null","percentage":false,"pointradius":5,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"span":6,"stack":true,"steppedLine":false,"targets":[{"refId":"A","target":"alias(percentileOfSeries(group(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.r_await),$percentile), \"Read Latency\")","textEditor":true},{"refId":"C","target":"alias(percentileOfSeries(group(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.w_await),$percentile), \"Write Latency\")","textEditor":true}],"thresholds":[{"colorMode":"custom","fill":false,"line":true,"lineColor":"rgba(178, 0, 0, 0.29)","op":"gt","value":54}],"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":null,"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":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(group(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.util),$percentile), \"disk busy %\")","textEditor":true}],"thresholds":[{"colorMode":"custom","fill":false,"line":true,"lineColor":"rgba(178, 0, 0, 0.29)","op":"gt","value":70}],"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":null,"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":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(group(collectd.$osd_servers.$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":"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":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":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(sumSeries(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.iops),\"IOPS\")","textEditor":true}],"thresholds":[],"timeFrom":null,"timeShift":null,"title":"Total 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":null,"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":6,"nullPointMode":"null","percentage":false,"pointradius":5,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"span":6,"stack":false,"steppedLine":false,"targets":[{"refId":"B","target":"groupByNode(collectd.$osd_servers.$domain.cpu.percent.{user,system,wait},1,\"sumSeries\")","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":null,"fill":1,"id":49,"legend":{"avg":false,"current":false,"max":false,"min":false,"show":true,"total":false,"values":false},"lines":true,"linewidth":1,"links":[{"dashUri":"db/network-usage-by-node","dashboard":"Network Usage by Node","includeVars":true,"keepTime":true,"targetBlank":true,"title":"Network Load by Node","type":"dashboard"}],"minSpan":6,"nullPointMode":"null","percentage":false,"pointradius":5,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"span":6,"stack":false,"steppedLine":false,"targets":[{"hide":true,"refId":"A","target":"collectd.$osd_servers.$domain.interface.*.if_octets.rx"},{"hide":true,"refId":"B","target":"collectd.$osd_servers.$domain.interface.*.if_octets.tx"},{"refId":"C","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)\")","textEditor":true}],"thresholds":[],"timeFrom":null,"timeShift":null,"title":"Network Load Across ALL OSDs","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":true}]}],"repeat":null,"repeatIteration":null,"repeatRowId":null,"showTitle":true,"title":"OSD Load Summary","titleSize":"h6"}],"schemaVersion":14,"style":"dark","tags":[],"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":"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":"95","value":"95"},"hide":0,"includeAll":false,"label":"Percentile","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":"ceph-1","value":"ceph-1"},{"selected":false,"text":"ceph-2","value":"ceph-2"},{"selected":false,"text":"ceph-3","value":"ceph-3"}],"query":"ceph-1,ceph-2,ceph-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":"Ceph Backend Storage","version":5}} \ No newline at end of file diff --git a/dashboards/current/ceph-frontend.json b/dashboards/current/ceph-frontend.json new file mode 100644 index 0000000..b747f67 --- /dev/null +++ b/dashboards/current/ceph-frontend.json @@ -0,0 +1 @@ +{"meta":{"type":"db","canSave":true,"canEdit":true,"canStar":true,"slug":"ceph-frontend","expires":"0001-01-01T00:00:00Z","created":"2017-06-07T20:56:52Z","updated":"2017-06-10T02:12:00Z","updatedBy":"admin","createdBy":"admin","version":10},"dashboard":{"annotations":{"list":[]},"editable":true,"gnetId":null,"graphTooltip":0,"hideControls":false,"id":3,"links":[],"refresh":"10s","rows":[{"collapse":false,"height":"350px","panels":[{"aliasColors":{},"bars":false,"dashLength":10,"dashes":false,"datasource":null,"fill":5,"id":1,"legend":{"avg":false,"current":false,"max":false,"min":false,"show":true,"total":false,"values":false},"lines":true,"linewidth":2,"links":[{"type":"dashboard"}],"minSpan":6,"nullPointMode":"null","percentage":false,"pointradius":5,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"span":6,"stack":true,"steppedLine":false,"targets":[{"refId":"A","target":"groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.*.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":null,"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":"null","percentage":false,"pointradius":5,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"span":6,"stack":true,"steppedLine":false,"targets":[{"refId":"A","target":"groupByNode(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.*.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}]}],"repeat":null,"repeatIteration":null,"repeatRowId":null,"showTitle":false,"title":"Dashboard Row","titleSize":"h6"},{"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":true,"total":false,"values":false},"lines":true,"linewidth":1,"links":[],"minSpan":4,"nullPointMode":"null","percentage":false,"pointradius":5,"points":false,"renderer":"flot","repeat":"pool_name","scopedVars":{"pool_name":{"selected":false,"text":"ec","value":"ec"}},"seriesOverrides":[],"spaceLength":10,"span":4,"stack":false,"steppedLine":false,"targets":[{"refId":"A","target":"alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec),\"Reads\")","textEditor":true},{"refId":"B","target":"alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec),\"Writes\")","textEditor":true}],"thresholds":[],"timeFrom":null,"timeShift":null,"title":"$pool_name Pool 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":null,"fill":1,"id":9,"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","repeat":null,"repeatIteration":1497060623640,"repeatPanelId":5,"scopedVars":{"pool_name":{"selected":false,"text":"iscsi","value":"iscsi"}},"seriesOverrides":[],"spaceLength":10,"span":4,"stack":false,"steppedLine":false,"targets":[{"refId":"A","target":"alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec),\"Reads\")","textEditor":true},{"refId":"B","target":"alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec),\"Writes\")","textEditor":true}],"thresholds":[],"timeFrom":null,"timeShift":null,"title":"$pool_name Pool 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":null,"fill":1,"id":10,"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","repeat":null,"repeatIteration":1497060623640,"repeatPanelId":5,"scopedVars":{"pool_name":{"selected":false,"text":"rbd","value":"rbd"}},"seriesOverrides":[],"spaceLength":10,"span":4,"stack":false,"steppedLine":false,"targets":[{"refId":"A","target":"alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_op_per_sec),\"Reads\")","textEditor":true},{"refId":"B","target":"alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_op_per_sec),\"Writes\")","textEditor":true}],"thresholds":[],"timeFrom":null,"timeShift":null,"title":"$pool_name Pool 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}]}],"repeat":null,"repeatIteration":null,"repeatRowId":null,"showTitle":false,"title":"Dashboard Row","titleSize":"h6"},{"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":4,"nullPointMode":"null","percentage":false,"pointradius":5,"points":false,"renderer":"flot","repeat":"pool_name","scopedVars":{"pool_name":{"selected":false,"text":"ec","value":"ec"}},"seriesOverrides":[],"spaceLength":10,"span":4,"stack":false,"steppedLine":false,"targets":[{"refId":"A","target":"alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec),\"Reads\")","textEditor":true},{"refId":"B","target":"alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec),\"Writes\")","textEditor":true}],"thresholds":[],"timeFrom":null,"timeShift":null,"title":"$pool_name Pool Throughput","tooltip":{"shared":true,"sort":0,"value_type":"individual"},"type":"graph","xaxis":{"buckets":null,"mode":"time","name":null,"show":true,"values":[]},"yaxes":[{"format":"bytes","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":1,"id":11,"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","repeat":null,"repeatIteration":1497060623640,"repeatPanelId":8,"scopedVars":{"pool_name":{"selected":false,"text":"iscsi","value":"iscsi"}},"seriesOverrides":[],"spaceLength":10,"span":4,"stack":false,"steppedLine":false,"targets":[{"refId":"A","target":"alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec),\"Reads\")","textEditor":true},{"refId":"B","target":"alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec),\"Writes\")","textEditor":true}],"thresholds":[],"timeFrom":null,"timeShift":null,"title":"$pool_name Pool Throughput","tooltip":{"shared":true,"sort":0,"value_type":"individual"},"type":"graph","xaxis":{"buckets":null,"mode":"time","name":null,"show":true,"values":[]},"yaxes":[{"format":"bytes","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":1,"id":12,"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","repeat":null,"repeatIteration":1497060623640,"repeatPanelId":8,"scopedVars":{"pool_name":{"selected":false,"text":"rbd","value":"rbd"}},"seriesOverrides":[],"spaceLength":10,"span":4,"stack":false,"steppedLine":false,"targets":[{"refId":"A","target":"alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.read_bytes_sec),\"Reads\")","textEditor":true},{"refId":"B","target":"alias(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.pools.$pool_name.write_bytes_sec),\"Writes\")","textEditor":true}],"thresholds":[],"timeFrom":null,"timeShift":null,"title":"$pool_name Pool Throughput","tooltip":{"shared":true,"sort":0,"value_type":"individual"},"type":"graph","xaxis":{"buckets":null,"mode":"time","name":null,"show":true,"values":[]},"yaxes":[{"format":"bytes","label":"Throughput","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":false,"title":"Dashboard Row","titleSize":"h6"},{"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":"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":"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":false,"title":"Dashboard Row","titleSize":"h6"}],"schemaVersion":14,"style":"dark","tags":[],"templating":{"list":[{"allValue":null,"current":{"selected":true,"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":{"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":{"tags":[],"text":"All","value":["$__all"]},"datasource":"Local","hide":0,"includeAll":true,"label":null,"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 - Frontend","version":10}} \ No newline at end of file diff --git a/dashboards/current/ceph-rados.json b/dashboards/current/ceph-rados.json new file mode 100644 index 0000000..edc6f08 --- /dev/null +++ b/dashboards/current/ceph-rados.json @@ -0,0 +1 @@ +{"meta":{"type":"db","canSave":true,"canEdit":true,"canStar":true,"slug":"ceph-rados","expires":"0001-01-01T00:00:00Z","created":"2017-06-07T20:56:52Z","updated":"2017-06-09T05:09:38Z","updatedBy":"admin","createdBy":"admin","version":4},"dashboard":{"annotations":{"list":[]},"editable":true,"gnetId":null,"graphTooltip":0,"hideControls":false,"id":4,"links":[{"asDropdown":true,"icon":"external link","includeVars":true,"keepTime":true,"tags":["overview"],"targetBlank":true,"title":"Shortcuts","type":"dashboards"}],"refresh":"10s","rows":[{"collapse":false,"height":256,"panels":[{"aliasColors":{},"bars":false,"dashLength":10,"dashes":false,"datasource":"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":[],"minSpan":6,"nullPointMode":"null","percentage":false,"pointradius":5,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"span":6,"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(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes), 'Raw')","textEditor":true},{"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(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.osd_bytes_used), 'Used')","textEditor":true}],"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":"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":"maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_pool)","textEditor":true}],"thresholds":"","title":"Pools","type":"singlestat","valueFontSize":"80%","valueMaps":[{"op":"=","text":"N/A","value":"null"}],"valueName":"avg"}],"repeat":null,"repeatIteration":null,"repeatRowId":null,"showTitle":true,"title":"Cluster Capacity","titleSize":"h6"},{"collapse":false,"height":250,"panels":[{"aliasColors":{},"bars":false,"dashLength":10,"dashes":false,"datasource":null,"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","percentage":false,"pointradius":5,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"span":6,"stack":false,"steppedLine":false,"targets":[{"refId":"A","target":"aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_pg),-1)","textEditor":true},{"refId":"B","target":"aliasByNode(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_pg_peering),-1)","textEditor":true}],"thresholds":[],"timeFrom":"24h","timeShift":null,"title":"Place Group States","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}]},{"columns":[{"text":"Current","value":"current"}],"datasource":"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"},{"alias":"Object State","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":"Count","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"},{"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(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_object), 'Total Objects')","textEditor":true},{"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(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_object_degraded), 'Objects degraded')","textEditor":true},{"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(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_object_misplaced), 'Objects misplaced')","textEditor":true},{"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(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_object_unfound), 'Objects unfound')","textEditor":true}],"title":"Object Summary","transform":"timeseries_aggregations","type":"table"},{"columns":[{"text":"Current","value":"current"}],"datasource":"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"},{"alias":"PG State","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":"Count","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"},{"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(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_pg), 'PGs')","textEditor":true},{"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(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_pg_active), 'Active PGs')","textEditor":true},{"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(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_pg_active_clean), 'Active+clean PGs')","textEditor":true},{"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(maxSeries(collectd.*.$domain.cephmetrics.gauge.$cluster_name.mon.num_pg_peering), 'PGs peering')","textEditor":true}],"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":["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":"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"}]},"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 - RADOS","version":4}} \ No newline at end of file diff --git a/dashboards/current/ceph-rgw-workload.json b/dashboards/current/ceph-rgw-workload.json new file mode 100644 index 0000000..6ce4c3f --- /dev/null +++ b/dashboards/current/ceph-rgw-workload.json @@ -0,0 +1 @@ +{"meta":{"type":"db","canSave":true,"canEdit":true,"canStar":true,"slug":"ceph-rgw-workload","expires":"0001-01-01T00:00:00Z","created":"2017-06-02T05:20:06Z","updated":"2017-06-06T19:52:12Z","updatedBy":"admin","createdBy":"admin","version":7},"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":307,"panels":[{"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":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_servers.$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_servers.$domain.cephmetrics.derive.$cluster_name.rgw.get_initial_lat_sum"},{"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":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_servers.$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_servers.$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":"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_servers.$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":null,"fill":1,"id":32,"legend":{"avg":false,"current":false,"max":false,"min":false,"show":false,"total":false,"values":false},"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":"aliasByMetric(collectd.$rgw_servers.$domain.cpu.percent.{user,system,wait,steal,softirq,interrupt})","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":null,"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_servers.$domain.interface.*.if_octets.rx), 'rx')"},{"refId":"B","target":"alias(sumSeries(collectd.$rgw_servers.$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(s) (S3/Swift)","titleSize":"h6"}],"schemaVersion":14,"style":"dark","tags":["overview"],"templating":{"list":[{"current":{"selected":true,"text":"obj-mon-1.storage.lab","value":"obj-mon-1.storage.lab"},"hide":2,"label":null,"name":"monitor","options":[{"selected":true,"text":"obj-mon-1.storage.lab","value":"obj-mon-1.storage.lab"}],"query":"obj-mon-1.storage.lab","type":"constant"},{"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":0,"includeAll":false,"label":null,"multi":true,"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":"Ceph - RGW Workload","version":7}} \ No newline at end of file diff --git a/dashboards/current/disk-busy-by-server.json b/dashboards/current/disk-busy-by-server.json new file mode 100644 index 0000000..e16b83a --- /dev/null +++ b/dashboards/current/disk-busy-by-server.json @@ -0,0 +1 @@ +{"meta":{"type":"db","canSave":true,"canEdit":true,"canStar":true,"slug":"disk-busy-by-server","expires":"0001-01-01T00:00:00Z","created":"2017-05-30T19:48:39Z","updated":"2017-06-06T19:36:47Z","updatedBy":"admin","createdBy":"admin","version":39},"dashboard":{"annotations":{"list":[]},"editable":true,"gnetId":null,"graphTooltip":0,"hideControls":true,"id":10,"links":[],"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":"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":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":1496738334164,"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":1496738334164,"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 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":["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":"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":39}} \ No newline at end of file diff --git a/dashboards/current/iops-by-server.json b/dashboards/current/iops-by-server.json new file mode 100644 index 0000000..5cdbcbb --- /dev/null +++ b/dashboards/current/iops-by-server.json @@ -0,0 +1 @@ +{"meta":{"type":"db","canSave":true,"canEdit":true,"canStar":true,"slug":"iops-by-server","expires":"0001-01-01T00:00:00Z","created":"2017-05-30T22:49:40Z","updated":"2017-06-06T19:38:17Z","updatedBy":"admin","createdBy":"admin","version":21},"dashboard":{"annotations":{"list":[]},"editable":true,"gnetId":null,"graphTooltip":0,"hideControls":true,"id":12,"links":[],"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":"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.$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":"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":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(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":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":1496738334165,"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.$ceph_cluster.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":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":1496738334165,"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.$ceph_cluster.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":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":["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"}]},"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":21}} \ No newline at end of file diff --git a/dashboards/current/latency-by-server.json b/dashboards/current/latency-by-server.json new file mode 100644 index 0000000..74d55ab --- /dev/null +++ b/dashboards/current/latency-by-server.json @@ -0,0 +1 @@ +{"meta":{"type":"db","canSave":true,"canEdit":true,"canStar":true,"slug":"latency-by-server","expires":"0001-01-01T00:00:00Z","created":"2017-05-30T23:01:27Z","updated":"2017-06-06T19:39:25Z","updatedBy":"admin","createdBy":"admin","version":24},"dashboard":{"annotations":{"list":[]},"editable":true,"gnetId":null,"graphTooltip":0,"hideControls":true,"id":13,"links":[],"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":"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.$cluster_name.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":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 Showing Max disk Latency","titleSize":"h6"},{"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(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 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":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":1496738334166,"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.$ceph_cluster.osd.*.perf.await),\"$osd_servers Max Latency\")","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":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":1496738334166,"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.$ceph_cluster.osd.*.perf.await),\"$osd_servers Max Latency\")","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":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 Disk Latency","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":["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":24}} \ No newline at end of file diff --git a/dashboards/current/network-usage-by-node.json b/dashboards/current/network-usage-by-node.json new file mode 100644 index 0000000..3bea07c --- /dev/null +++ b/dashboards/current/network-usage-by-node.json @@ -0,0 +1 @@ +{"meta":{"type":"db","canSave":true,"canEdit":true,"canStar":true,"slug":"network-usage-by-node","expires":"0001-01-01T00:00:00Z","created":"2017-06-01T03:21:27Z","updated":"2017-06-06T19:40:10Z","updatedBy":"admin","createdBy":"admin","version":14},"dashboard":{"annotations":{"list":[]},"editable":true,"gnetId":null,"graphTooltip":0,"hideControls":true,"id":14,"links":[{"asDropdown":true,"icon":"external link","tags":["overview"],"title":"Shortcuts","type":"dashboards"}],"refresh":"10s","rows":[{"collapse":false,"height":"250px","panels":[{"aliasColors":{},"bars":false,"dashLength":10,"dashes":false,"datasource":null,"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":[],"minSpan":12,"nullPointMode":"null","percentage":false,"pointradius":5,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"span":12,"stack":false,"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 Network Load by Node","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":false,"title":"Dashboard Row","titleSize":"h6"},{"collapse":false,"height":250,"panels":[{"aliasColors":{},"bars":false,"dashLength":10,"dashes":false,"datasource":null,"fill":1,"id":2,"legend":{"avg":false,"current":false,"hideZero":true,"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_servers Node Detail","type":"dashboard"}],"minSpan":4,"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":"aliasByNode(collectd.$osd_servers.$domain.interface.*.if_octets.*,-3,-1)","textEditor":true}],"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}]},{"aliasColors":{},"bars":false,"dashLength":10,"dashes":false,"datasource":null,"fill":1,"id":3,"legend":{"avg":false,"current":false,"hideZero":true,"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_servers Node Detail","type":"dashboard"}],"minSpan":4,"nullPointMode":"null","percentage":false,"pointradius":5,"points":false,"renderer":"flot","repeat":null,"repeatIteration":1496738334167,"repeatPanelId":2,"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":"aliasByNode(collectd.$osd_servers.$domain.interface.*.if_octets.*,-3,-1)","textEditor":true}],"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}]},{"aliasColors":{},"bars":false,"dashLength":10,"dashes":false,"datasource":null,"fill":1,"id":4,"legend":{"avg":false,"current":false,"hideZero":true,"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_servers Node Detail","type":"dashboard"}],"minSpan":4,"nullPointMode":"null","percentage":false,"pointradius":5,"points":false,"renderer":"flot","repeat":null,"repeatIteration":1496738334167,"repeatPanelId":2,"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":"aliasByNode(collectd.$osd_servers.$domain.interface.*.if_octets.*,-3,-1)","textEditor":true}],"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":false,"title":"Dashboard Row","titleSize":"h6"}],"schemaVersion":14,"style":"dark","tags":["overview"],"templating":{"list":[{"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":"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}]},"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":14}} \ No newline at end of file diff --git a/dashboards/current/osd-node-detail.json b/dashboards/current/osd-node-detail.json new file mode 100644 index 0000000..9cf8b7f --- /dev/null +++ b/dashboards/current/osd-node-detail.json @@ -0,0 +1 @@ +{"meta":{"type":"db","canSave":true,"canEdit":true,"canStar":true,"slug":"osd-node-detail","expires":"0001-01-01T00:00:00Z","created":"2017-05-30T22:40:05Z","updated":"2017-06-06T19:42:27Z","updatedBy":"admin","createdBy":"admin","version":20},"dashboard":{"annotations":{"list":[]},"editable":true,"gnetId":null,"graphTooltip":0,"hideControls":true,"id":11,"links":[],"refresh":"10s","rows":[{"collapse":false,"height":250,"panels":[{"aliasColors":{},"bars":false,"dashLength":10,"dashes":false,"datasource":null,"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":"null","percentage":false,"pointradius":5,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"span":6,"stack":false,"steppedLine":false,"targets":[{"refId":"A","target":"aliasByNode(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.util, -3)"}],"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":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":[],"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":"aliasByNode(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.await, -3)"}],"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":"short","label":"ms","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":false,"title":"Dashboard Row","titleSize":"h6"},{"collapse":false,"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":[],"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":"aliasByNode(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.bytes_per_sec, -3)"}],"thresholds":[],"timeFrom":null,"timeShift":null,"title":"$osd_servers Disk Throughput (MB/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":"MB/s","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":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","percentage":false,"pointradius":5,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"span":6,"stack":false,"steppedLine":false,"targets":[{"refId":"A","target":"aliasByNode(collectd.$osd_servers.$domain.cephmetrics.gauge.$cluster_name.osd.*.perf.iops, -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}]}],"repeat":null,"repeatIteration":null,"repeatRowId":null,"showTitle":false,"title":"Dashboard Row","titleSize":"h6"},{"collapse":false,"height":250,"panels":[{"aliasColors":{"interrupt":"#447EBC","steal":"#6D1F62","system":"#890F02","user":"#3F6833","wait":"#C15C17"},"bars":false,"dashLength":10,"dashes":false,"datasource":null,"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":"null","percentage":false,"pointradius":5,"points":false,"renderer":"flot","repeat":null,"seriesOverrides":[],"spaceLength":10,"span":6,"stack":true,"steppedLine":false,"targets":[{"refId":"A","target":"aliasByMetric(collectd.$osd_servers.$domain.cpu.percent.{system,user,wait,steal,nice,interrupt,softirq})","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":null,"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":"null","percentage":false,"pointradius":5,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"span":6,"stack":false,"steppedLine":false,"targets":[{"refId":"A","target":"aliasByNode(collectd.$osd_servers.$domain.interface.*.if_octets.*,-3,-1)","textEditor":true}],"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":false,"title":"Dashboard Row","titleSize":"h6"}],"schemaVersion":14,"style":"dark","tags":[],"templating":{"list":[{"allValue":null,"current":{"selected":false,"text":"obj-osd-1","value":"obj-osd-1"},"hide":2,"includeAll":false,"label":null,"multi":false,"name":"osd_servers","options":[{"selected":true,"text":"obj-osd-1","value":"obj-osd-1"}],"query":"obj-osd-1","type":"custom"},{"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":"cluster_name","options":[],"query":"collectd.*.$domain.cephmetrics.gauge.*","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":"OSD Node Detail","version":20}} \ No newline at end of file diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml new file mode 100644 index 0000000..c102b62 --- /dev/null +++ b/docker/docker-compose.yml @@ -0,0 +1,23 @@ +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 diff --git a/etc/collectd.conf b/etc/collectd.conf new file mode 100644 index 0000000..5c8a26d --- /dev/null +++ b/etc/collectd.conf @@ -0,0 +1,18 @@ +# 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 + + + Globals true + + +LoadPlugin "threshold" +LoadPlugin "aggregation" + +Include "/etc/collectd.d/*.conf" diff --git a/etc/collectd.d/cephmetrics.conf b/etc/collectd.d/cephmetrics.conf new file mode 100644 index 0000000..d671c0a --- /dev/null +++ b/etc/collectd.d/cephmetrics.conf @@ -0,0 +1,10 @@ +LoadPlugin "python" + + + ModulePath "/usr/lib64/collectd/python-plugins" + + Import "cephmetrics" + + ClusterName "ceph" + + diff --git a/etc/collectd.d/cpu.conf b/etc/collectd.d/cpu.conf new file mode 100644 index 0000000..bd65ef0 --- /dev/null +++ b/etc/collectd.d/cpu.conf @@ -0,0 +1,17 @@ +LoadPlugin cpu + + + ValuesPercentage true + ReportByCpu false + + + + + + Instance user + FailureMax 90 + WarningMax 80 + + + + diff --git a/etc/collectd.d/memory.conf b/etc/collectd.d/memory.conf new file mode 100644 index 0000000..481950c --- /dev/null +++ b/etc/collectd.d/memory.conf @@ -0,0 +1,26 @@ +LoadPlugin memory + + + ValuesPercentage true + + + + + Plugin "memory" + Type "memory" + + GroupBy "Host" + + CalculateSum true + + + + + + + Instance used + FailureMax 90 + WarningMax 80 + + + diff --git a/etc/collectd.d/nics.conf b/etc/collectd.d/nics.conf new file mode 100644 index 0000000..7494ca1 --- /dev/null +++ b/etc/collectd.d/nics.conf @@ -0,0 +1 @@ +LoadPlugin interface diff --git a/etc/collectd.d/write_graphite.conf b/etc/collectd.d/write_graphite.conf new file mode 100644 index 0000000..b93ea61 --- /dev/null +++ b/etc/collectd.d/write_graphite.conf @@ -0,0 +1,19 @@ +LoadPlugin "write_graphite" + + + 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 + + + diff --git a/etc/grafana/grafana.ini b/etc/grafana/grafana.ini new file mode 100644 index 0000000..84328e7 --- /dev/null +++ b/etc/grafana/grafana.ini @@ -0,0 +1,407 @@ +##################### 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 + +# 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 = diff --git a/screenshots/archive/dashboard-2017-05-19.png b/screenshots/archive/dashboard-2017-05-19.png new file mode 100644 index 0000000..fde57c5 Binary files /dev/null and b/screenshots/archive/dashboard-2017-05-19.png differ diff --git a/screenshots/archive/dashboard-2017-05-24.png b/screenshots/archive/dashboard-2017-05-24.png new file mode 100644 index 0000000..3701904 Binary files /dev/null and b/screenshots/archive/dashboard-2017-05-24.png differ diff --git a/screenshots/archive/dashboard-2017-05-26.png b/screenshots/archive/dashboard-2017-05-26.png new file mode 100644 index 0000000..611f9d6 Binary files /dev/null and b/screenshots/archive/dashboard-2017-05-26.png differ diff --git a/screenshots/archive/dashboard-2017-05-29.png b/screenshots/archive/dashboard-2017-05-29.png new file mode 100644 index 0000000..6089f79 Binary files /dev/null and b/screenshots/archive/dashboard-2017-05-29.png differ diff --git a/screenshots/at-a-glance.png b/screenshots/at-a-glance.png new file mode 100644 index 0000000..c561d78 Binary files /dev/null and b/screenshots/at-a-glance.png differ diff --git a/screenshots/ceph-backend.png b/screenshots/ceph-backend.png new file mode 100644 index 0000000..8da34f0 Binary files /dev/null and b/screenshots/ceph-backend.png differ diff --git a/screenshots/ceph-frontend.png b/screenshots/ceph-frontend.png new file mode 100644 index 0000000..cb3dee4 Binary files /dev/null and b/screenshots/ceph-frontend.png differ diff --git a/screenshots/ceph-rados.png b/screenshots/ceph-rados.png new file mode 100644 index 0000000..630d4ad Binary files /dev/null and b/screenshots/ceph-rados.png differ diff --git a/screenshots/ceph-rgw.png b/screenshots/ceph-rgw.png new file mode 100644 index 0000000..ad271c9 Binary files /dev/null and b/screenshots/ceph-rgw.png differ diff --git a/screenshots/disk-busy-by-server.png b/screenshots/disk-busy-by-server.png new file mode 100644 index 0000000..2b5d4a2 Binary files /dev/null and b/screenshots/disk-busy-by-server.png differ diff --git a/screenshots/disk-latency-by-server.png b/screenshots/disk-latency-by-server.png new file mode 100644 index 0000000..8bfa17a Binary files /dev/null and b/screenshots/disk-latency-by-server.png differ diff --git a/screenshots/iops-by-server.png b/screenshots/iops-by-server.png new file mode 100644 index 0000000..189ca46 Binary files /dev/null and b/screenshots/iops-by-server.png differ diff --git a/screenshots/network-load.png b/screenshots/network-load.png new file mode 100644 index 0000000..6f49966 Binary files /dev/null and b/screenshots/network-load.png differ diff --git a/screenshots/osd-node-details.png b/screenshots/osd-node-details.png new file mode 100644 index 0000000..21be086 Binary files /dev/null and b/screenshots/osd-node-details.png differ diff --git a/setup/add_datasource.json b/setup/add_datasource.json new file mode 100644 index 0000000..64d9ef8 --- /dev/null +++ b/setup/add_datasource.json @@ -0,0 +1,8 @@ +{ + "name":"Local", + "type":"graphite", + "url":"http://192.168.1.52", + "access":"proxy", + "basicAuth":false, + "isDefault":true +} diff --git a/tests/testosd.py b/tests/testosd.py new file mode 100644 index 0000000..53dc139 --- /dev/null +++ b/tests/testosd.py @@ -0,0 +1,21 @@ +#!/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()