grafana 0.8.2

data/lib/grafana/annotations.rb

@@ -0,0 +1,40 @@
+
+module Grafana
+
+  # http://docs.grafana.org/http_api/annotations/
+  #
+  module Annotations
+
+    # Find Annotations
+    # http://docs.grafana.org/http_api/annotations/#find-annotations
+    # GET /api/annotations?from=1506676478816&to=1507281278816&tags=tag1&tags=tag2&limit=100
+    def find_annotation( params ); end
+
+    # Create Annotation
+    # http://docs.grafana.org/http_api/annotations/#create-annotation
+    # POST /api/annotations
+    def create_annotation( params ); end
+
+    # Create Annotation in Graphite format
+    # http://docs.grafana.org/http_api/annotations/#create-annotation-in-graphite-format
+    # POST /api/annotations/graphite
+    def create_annotation_graphite( params ); end
+
+    # Update Annotation
+    # http://docs.grafana.org/http_api/annotations/#update-annotation
+    # PUT /api/annotations/:id
+    def update_annotation( params ); end
+
+    # Delete Annotation By Id
+    # http://docs.grafana.org/http_api/annotations/#delete-annotation-by-id
+    # DELETE /api/annotation/:id
+    def delete_annotation( params ); end
+
+    # Delete Annotation By RegionId
+    # http://docs.grafana.org/http_api/annotations/#delete-annotation-by-regionid
+    # DELETE /api/annotation/region/:id
+    def delete_annotation_by_region( params ); end
+
+  end
+
+end

data/lib/grafana/client.rb

@@ -0,0 +1,126 @@
+
+require 'ruby_dig' if RUBY_VERSION < '2.3'
+
+require 'rest-client'
+require 'json'
+require 'timeout'
+
+require_relative 'version'
+require_relative 'validator'
+require_relative 'login'
+require_relative 'network'
+require_relative 'tools'
+require_relative 'admin'
+require_relative 'annotations'
+require_relative 'user'
+require_relative 'users'
+require_relative 'datasource'
+require_relative 'organization'
+require_relative 'organizations'
+require_relative 'dashboard'
+require_relative 'dashboard_versions'
+require_relative 'snapshot'
+
+# -------------------------------------------------------------------------------------------------------------------
+#
+# @abstract # Namespace for classes and modules that handle all Grafana API calls
+#
+# @author Bodo Schulz <bodo@boone-schulz.de>
+#
+#
+module Grafana
+
+  # Abstract base class for the API calls.
+  # Provides some helper methods
+  #
+  # @author Bodo Schulz
+  #
+  class Client
+
+    include Logging
+
+    include Grafana::Version
+    include Grafana::Validator
+    include Grafana::Login
+    include Grafana::Network
+    include Grafana::Tools
+    include Grafana::Admin
+    include Grafana::Annotations
+    include Grafana::User
+    include Grafana::Users
+    include Grafana::Datasource
+    include Grafana::Organization
+    include Grafana::Organizations
+    include Grafana::Dashboard
+    include Grafana::DashboardVersions
+    include Grafana::Snapshot
+
+    attr_accessor :debug
+
+    # Create a new instance of Class
+    #
+    # @param [Hash, #read] settings the settings for Grafana
+    # @option settings [String] :host ('localhost') the Grafana Hostname
+    # @option settings [Integer] :port (3000) the Grafana HTTP Port
+    # @option settings [String] :url_path ('')
+    # @option settings [Bool] :ssl (false)
+    # @option settings [Integer] :timeout (5)
+    # @option settings [Integer] :open_timeout (5)
+    # @option settings [Hash] :http_headers ({})
+    # @option settings [Bool] :debug (false)
+    #
+    # @example to create an new Instance
+    #    config = {
+    #      grafana: {
+    #        host: '192.168.33.5',
+    #        port: 3000,
+    #        url_path: '/grafana',
+    #        ssl: false,
+    #        timeout: 10,
+    #        open_timeout: 10,
+    #        debug: true
+    #    }
+    #
+    #    @grafana = Grafana::Client.new(config)
+    #
+    #
+    def initialize( settings )
+
+      raise ArgumentError.new('only Hash are allowed') unless( settings.is_a?(Hash) )
+      raise ArgumentError.new('missing settings') if( settings.size.zero? )
+
+      host                = settings.dig(:grafana, :host)          || 'localhost'
+      port                = settings.dig(:grafana, :port)          || 3000
+      url_path            = settings.dig(:grafana, :url_path)      || ''
+      ssl                 = settings.dig(:grafana, :ssl)           || false
+      @timeout            = settings.dig(:grafana, :timeout)       || 5
+      @open_timeout       = settings.dig(:grafana, :open_timeout)  || 5
+      @http_headers       = settings.dig(:grafana, :http_headers)  || {}
+      @debug              = settings.dig(:debug)                   || false
+
+      raise ArgumentError.new('missing \'host\'') if( host.nil? )
+
+      raise ArgumentError.new(format('wrong type. \'port\' must be an Integer, given \'%s\'', port.class.to_s)) unless( port.is_a?(Integer) )
+      raise ArgumentError.new(format('wrong type. \'url_path\' must be an String, given \'%s\'', url_path.class.to_s)) unless( url_path.is_a?(String) )
+      raise ArgumentError.new(format('wrong type. \'ssl\' must be an Boolean, given \'%s\'', ssl.class.to_s)) unless( ssl.is_a?(Boolean) )
+      raise ArgumentError.new(format('wrong type. \'timeout\' must be an Integer, given \'%s\'', @timeout.class.to_s)) unless( @timeout.is_a?(Integer) )
+      raise ArgumentError.new(format('wrong type. \'open_timeout\' must be an Integer, given \'%s\'', @open_timeout.class.to_s)) unless( @open_timeout.is_a?(Integer) )
+
+      protocoll = ssl == true ? 'https' : 'http'
+      raise ArgumentError.new(format('wrong \'protocoll\'. only \'http\' or \'https\' allowed, given \'%s\'', protocoll)) if( %w[http https].include?(protocoll.downcase) == false )
+
+      @url      = format( '%s://%s:%d%s', protocoll, host, port, url_path )
+    end
+
+    def self.logger
+      @@logger ||= defined?(Logging) ? Logging.logger : Logger.new(STDOUT)
+    end
+
+    def self.logger=(logger)
+      @@logger = logger
+    end
+
+  end
+
+end
+

data/lib/grafana/dashboard.rb

@@ -0,0 +1,149 @@
+
+module Grafana
+
+  # http://docs.grafana.org/http_api/dashboard/
+  #
+  module Dashboard
+
+
+    # Get dashboard
+    # GET /api/dashboards/db/:slug
+    def dashboard( name )
+
+      raise ArgumentError.new(format('wrong type. \'name\' must be an String, given \'%s\'', name.class.to_s)) unless( name.is_a?(String) )
+      raise ArgumentError.new('missing name') if( name.size.zero? )
+
+#       raise ArgumentError.new('name must be an String') unless( name.is_a?(String) )
+
+      endpoint = format( '/api/dashboards/db/%s', slug(name) )
+
+      @logger.debug( "Attempting to get dashboard (GET /api/dashboards/db/#{name})" ) if @debug
+
+      get( endpoint )
+    end
+
+    # Create / Update dashboard
+    # POST /api/dashboards/db
+    def create_dashboard( params )
+
+      raise ArgumentError.new(format('wrong type. params must be an Hash, given %s', params.class.to_s ) ) unless( params.is_a?(Hash) )
+
+      title     = params.dig(:title)
+      dashboard = params.dig(:dashboard)
+
+      # raise ArgumentError.new('missing title') if( title.nil? )
+      raise ArgumentError.new('missing dashboard') if( dashboard.nil? )
+      raise ArgumentError.new(format('wrong type. dashboard must be an Hash, given %s', dashboard.class.to_s ) ) unless( dashboard.is_a?(Hash) )
+
+      endpoint = '/api/dashboards/db'
+      # title     = slug(title)
+
+      # dashboard = JSON.parse( dashboard ) if( dashboard.is_a?(String) )
+      dashboard = regenerate_template_ids( dashboard )
+
+      if( title.nil? )
+        db = JSON.parse( dashboard ) if( dashboard.is_a?(String) )
+        title = db.dig('dashboard','title')
+      end
+
+      @logger.debug("Creating dashboard: #{title} (POST /api/dashboards/db)") if @debug
+
+      post( endpoint, dashboard )
+    end
+
+    # Delete dashboard
+    # DELETE /api/dashboards/db/:slug
+    def delete_dashboard( name )
+
+      endpoint = format( '/api/dashboards/db/%s', slug(name) )
+
+      @logger.debug("Deleting dashboard #{slug(name)} (DELETE #{endpoint})") if @debug
+
+      delete(endpoint)
+    end
+
+    # Gets the home dashboard
+    # GET /api/dashboards/home
+    def home_dashboard
+
+      endpoint = '/api/dashboards/home'
+
+      @logger.debug("Attempting to get home dashboard (GET #{endpoint})") if @debug
+
+      get(endpoint)
+    end
+
+    # Tags for Dashboard
+    # GET /api/dashboards/tags
+    def dashboard_tags
+
+      endpoint = '/api/dashboards/tags'
+
+      @logger.debug("Attempting to get dashboard tags(GET #{endpoint})") if @debug
+
+      get(endpoint)
+    end
+
+    # Search Dashboards
+    # GET /api/search/
+    #
+    #    searchDashboards( { :tags   => host } )
+    #    searchDashboards( { :tags   => [ host, 'tag1' ] } )
+    #    searchDashboards( { :tags   => [ 'tag2' ] } )
+    #    searchDashboards( { :query  => title } )
+    #    searchDashboards( { :starred => true } )
+    def search_dashboards( params = {} )
+
+      raise ArgumentError.new(format('wrong type. \'params\' must be an Hash, given \'%s\'', params.class.to_s)) unless( params.is_a?(Hash) )
+
+      query   = params.dig(:query)
+      starred = params.dig(:starred)
+      tags    = params.dig(:tags)
+      api     = []
+
+      api << format( 'query=%s', CGI.escape( query ) ) unless  query.nil?
+      api << format( 'starred=%s', starred ? 'true' : 'false' ) unless( starred.nil? )
+
+      unless( tags.nil? )
+
+        tags = tags.join( '&tag=' ) if( tags.is_a?( Array ) )
+
+        api << format( 'tag=%s', tags )
+      end
+
+      api = api.join( '&' )
+
+      endpoint = format( '/api/search/?%s' , api )
+
+      @logger.debug("Attempting to search for dashboards (GET #{endpoint})") if @debug
+
+      get( endpoint )
+    end
+
+
+    def import_dashboards_from_directory( directory )
+
+      raise ArgumentError.new('directory must be an String') unless( directory.is_a?(String) )
+
+      result = {}
+
+      dirs = Dir.glob( format( '%s/**.json', directory ) ).sort
+
+      dirs.each do |f|
+
+        @logger.debug( format( 'import \'%s\'', f ) ) if @debug
+
+        dashboard = File.read( f )
+        dashboard = JSON.parse( dashboard )
+        title     = dashboard.dig('dashboard','title') || f
+
+        result[f.to_s] ||= {}
+        result[f.to_s] = create_dashboard( title: title, dashboard: dashboard )
+      end
+
+      result
+    end
+
+  end
+
+end

data/lib/grafana/dashboard_versions.rb

@@ -0,0 +1,30 @@
+
+module Grafana
+
+  # http://docs.grafana.org/http_api/annotations/
+  #
+  module DashboardVersions
+
+    # Get all dashboard versions
+    # http://docs.grafana.org/http_api/dashboard_versions/#get-all-dashboard-versions
+    # GET /api/dashboards/id/:dashboardId/versions
+    def dashboard_all_versions( params ); end
+
+    # Get dashboard version
+    # http://docs.grafana.org/http_api/dashboard_versions/#get-dashboard-version
+    # GET /api/dashboards/id/:dashboardId/versions/:id
+    def dashboard_version( params ); end
+
+    # Restore dashboard
+    # http://docs.grafana.org/http_api/dashboard_versions/#restore-dashboard
+    # POST /api/dashboards/id/:dashboardId/restore
+    def restore_dashboard( params ); end
+
+    # Compare dashboard versions
+    # http://docs.grafana.org/http_api/dashboard_versions/#compare-dashboard-versions
+    # POST /api/dashboards/calculate-diff
+    def compare_dashboard_version( params ); end
+
+  end
+
+end

data/lib/grafana/datasource.rb

@@ -0,0 +1,271 @@
+
+module Grafana
+
+  # http://docs.grafana.org/http_api/datasource/
+  #
+  module Datasource
+
+    # Get all datasources
+    #
+    # @example
+    #    datasources
+    #
+    # @return [Hash]
+    #
+    def datasources
+
+      endpoint = '/api/datasources'
+
+      @logger.debug("Attempting to get all existing data sources (GET #{endpoint})") if @debug
+
+      datasources = get( endpoint )
+
+      if  datasources.nil? || datasources.dig('status').to_i != 200
+        return {
+          'status' => 404,
+          'message' => 'No Datasources found'
+        }
+      end
+
+      datasources = datasources.dig('message')
+
+      datasource_map = {}
+      datasources.each do |ds|
+        datasource_map[ds['id']] = ds
+      end
+
+      datasource_map
+    end
+
+    # Get a single datasources by Id or Name
+    #
+    # @example
+    #    datasource( 1 )
+    #    datasource( 'foo' )
+    #
+    # @return [Hash]
+    #
+    def datasource( datasource_id )
+
+      raise ArgumentError.new(format('wrong type. user \'datasource_id\' must be an String (for an Datasource name) or an Integer (for an Datasource Id), given \'%s\'', datasource_id.class.to_s)) if( datasource_id.is_a?(String) && datasource_id.is_a?(Integer) )
+      raise ArgumentError.new('missing \'datasource_id\'') if( datasource_id.size.zero? )
+
+      if(datasource_id.is_a?(String))
+        data = datasources.select { |_k,v| v['name'] == datasource_id }
+        datasource_id = data.keys.first if( data )
+      end
+
+      if( datasource_id.nil? )
+        return {
+          'status' => 404,
+          'message' => format( 'No Datasource \'%s\' found', datasource_id)
+        }
+      end
+
+      raise format('DataSource Id can not be 0') if( datasource_id.zero? )
+
+      endpoint = format('/api/datasources/%d', datasource_id )
+
+      @logger.debug("Attempting to get existing data source Id #{datasource_id} (GET #{endpoint})") if  @debug
+
+      get(endpoint)
+    end
+
+    # Get a single data source by Name
+    # GET /api/datasources/name/:name
+
+    # Get data source Id by Name
+    # GET /api/datasources/id/:name
+
+    # Update an existing data source
+    #
+    # merge an current existing datasource configuration with the new values
+    #
+    # @param [Hash] params
+    # @option params [Hash] data
+    # @option params [Mixed] datasource Datasource Name (String) or Datasource Id (Integer)
+    #
+    # @example
+    #    update_datasource(
+    #      datasource: 'graphite',
+    #      data: { url: 'http://localhost:2003' }
+    #    )
+    #
+    # @return [Hash]
+    #
+    def update_datasource( params )
+
+      raise ArgumentError.new(format('wrong type. \'params\' must be an Hash, given \'%s\'', params.class.to_s)) unless( params.is_a?(Hash) )
+      raise ArgumentError.new('missing \'params\'') if( params.size.zero? )
+
+      data       = validate( params, required: true, var: 'data', type: Hash )
+      datasource = validate( params, required: true, var: 'datasource' )
+
+      raise ArgumentError.new(format('wrong type. user \'datasource\' must be an String (for an Datasource name) or an Integer (for an Datasource Id), given \'%s\'', datasource.class.to_s)) if( datasource.is_a?(String) && datasource.is_a?(Integer) )
+
+      existing_ds = datasource(datasource)
+
+      existing_ds.reject! { |x| x == 'status' }
+      existing_ds = existing_ds.deep_string_keys
+
+      datasource_id = existing_ds.dig('id')
+
+      payload = data.deep_string_keys
+      payload = existing_ds.merge(payload).deep_symbolize_keys
+
+      endpoint = format('/api/datasources/%d', datasource_id )
+      @logger.debug("Updating data source Id #{datasource_id} (GET #{endpoint})") if  @debug
+      logger.debug(payload.to_json) if(@debug)
+
+      put( endpoint, payload.to_json )
+    end
+
+    # Create data source
+    #
+    # @param [Hash] params
+    # @option params [String] type Datasource Type - (required) (grafana graphite cloudwatch elasticsearch prometheus influxdb mysql opentsdb postgres)
+    # @option params [String] name  Datasource Name - (required)
+    # @option params [String] database  Datasource Database - (required)
+    # @option params [String] access (proxy) Acess Type - (required) (proxy or direct)
+    # @option params [Boolean] default (false)
+    # @option params [String] user
+    # @option params [String] password
+    # @option params [String] url Datasource URL - (required)
+    # @option params [Hash] json_data
+    # @option params [Hash] json_secure
+    # @option params [String] basic_user
+    # @option params [String] basic_password
+    #
+    # @example
+    #    params = {
+    #      name: 'graphite',
+    #      type: 'graphite',
+    #      database: 'graphite',
+    #      url: 'http://localhost:8080'
+    #    }
+    #    create_datasource(params)
+    #
+    #    params = {
+    #      name: 'graphite',
+    #      type: 'graphite',
+    #      database: 'graphite',
+    #      default: true,
+    #      url: 'http://localhost:8080',
+    #      json_data: { graphiteVersion: '1.1' }
+    #    }
+    #    create_datasource(params)
+    #
+    #    params = {
+    #      name: 'test_datasource',
+    #      type: 'cloudwatch',
+    #      url: 'http://monitoring.us-west-1.amazonaws.com',
+    #      json_data: {
+    #        authType: 'keys',
+    #        defaultRegion: 'us-west-1'
+    #      },
+    #      json_secure: {
+    #        accessKey: 'Ol4pIDpeKSA6XikgOl4p',
+    #        secretKey: 'dGVzdCBrZXkgYmxlYXNlIGRvbid0IHN0ZWFs'
+    #      }
+    #    }
+    #    create_datasource(params)
+    #
+    # @return [Hash]
+    #
+    def create_datasource( params )
+
+      raise ArgumentError.new(format('wrong type. \'params\' must be an Hash, given \'%s\'', params.class.to_s)) unless( params.is_a?(Hash) )
+      raise ArgumentError.new('missing \'params\'') if( params.size.zero? )
+
+      type        = validate( params, required: true, var: 'type', type: String )
+      name        = validate( params, required: true, var: 'name', type: String )
+      database    = validate( params, required: true, var: 'database', type: String )
+      access      = validate( params, required: false, var: 'access', type: String ) || 'proxy'
+      default     = validate( params, required: false, var: 'default', type: Boolean ) || false
+      user        = validate( params, required: false, var: 'user', type: String )
+      password    = validate( params, required: false, var: 'password', type: String )
+      url         = validate( params, required: true, var: 'url', type: String )
+      json_data   = validate( params, required: false, var: 'json_data', type: Hash )
+      json_secure = validate( params, required: false, var: 'json_secure', type: Hash )
+      ba_user     = validate( params, required: false, var: 'basic_user', type: String )
+      ba_password = validate( params, required: false, var: 'basic_password', type: String )
+
+      basic_auth  = false
+      basic_auth  = true unless( ba_user.nil? && ba_password.nil? )
+
+      valid_types = %w[grafana graphite cloudwatch elasticsearch prometheus influxdb mysql opentsdb postgres]
+
+      raise ArgumentError.new(format('wrong datasource type. only %s allowed, given \%s\'', valid_types.join(', '), type)) if( valid_types.include?(type.downcase) == false )
+
+      payload = {
+        isDefault: default,
+        basicAuth: basic_auth,
+        basicAuthUser: ba_user,
+        basicAuthPassword: ba_password,
+        name: name,
+        type: type,
+        url: url,
+        access: access,
+        jsonData: json_data,
+        secureJsonData: json_secure
+      }
+
+      payload.reject!{ |_k, v| v.nil? }
+
+      if( @debug )
+        logger.debug("Creating data source: #{name} (database: #{database})")
+        logger.debug( payload.to_json )
+      end
+
+      endpoint = '/api/datasources'
+      post(endpoint, payload.to_json)
+    end
+
+    # Delete an existing data source by id
+    #
+    # @param [Mixed] datasource_id Datasource Name (String) or Datasource Id (Integer) for delete Datasource
+    #
+    # @example
+    #    delete_datasource( 1 )
+    #    delete_datasource( 'foo' )
+    #
+    # @return [Hash]
+    #
+    def delete_datasource( datasource_id )
+
+      raise ArgumentError.new(format('wrong type. user \'datasource_id\' must be an String (for an Datasource name) or an Integer (for an Datasource Id), given \'%s\'', datasource_id.class.to_s)) if( datasource_id.is_a?(String) && datasource_id.is_a?(Integer) )
+      raise ArgumentError.new('missing \'datasource_id\'') if( datasource_id.size.zero? )
+
+      if(datasource_id.is_a?(String))
+        data = datasources.select { |_k,v| v['name'] == datasource_id }
+        datasource_id = data.keys.first if( data )
+      end
+
+      if( datasource_id.nil? )
+        return {
+          'status' => 404,
+          'message' => format( 'No Datasource \'%s\' found', datasource_id)
+        }
+      end
+
+      raise format('Data Source Id can not be 0') if( datasource_id.zero? )
+
+      endpoint = format('/api/datasources/%d', datasource_id)
+      logger.debug("Deleting data source Id #{datasource_id} (DELETE #{endpoint})") if @debug
+
+      delete(endpoint)
+    end
+
+
+    # Delete an existing data source by name
+    # DELETE /api/datasources/name/:datasourceName
+
+    # Data source proxy calls
+    # GET /api/datasources/proxy/:datasourceId/*
+
+
+
+  end
+
+end
+