grafana 0.8.5 → 1.1.0

data/lib/grafana/folder_and_dashboard_search.rb

@@ -0,0 +1,57 @@
+module Grafana
+
+  # http://docs.grafana.org/http_api/folder_dashboard_search/#folder-dashboard-search-api
+  #
+  module FolderSearch
+
+    # Search folders and dashboards
+    # GET /api/search/
+    #
+    # Query parameters:
+    #
+    #  - query - Search Query
+    #  - tag - List of tags to search for
+    #  - type - Type to search for, dash-folder or dash-db
+    #  - dashboardIds - List of dashboard id's to search for
+    #  - folderIds - List of folder id's to search in for dashboards
+    #  - starred - Flag indicating if only starred Dashboards should be returned
+    #  - limit - Limit the number of returned results
+    def folder_and_dashboard_search(params)
+
+      raise ArgumentError.new(format('wrong type. \'params\' must be an Hash, given \'%s\'', params.class.to_s)) unless( params.is_a?(Hash) )
+
+      v, mv = version.values
+      return { 'status' => 404, 'message' => format( 'team has been supported in Grafana since version 5. you use version %s', v) } if(mv < 5)
+
+      query         = validate( params, required: false, var: 'query'       , type: String )
+      tag           = validate( params, required: false, var: 'tag '        , type: String )
+      type          = validate( params, required: false, var: 'type'        , type: String )
+      dashboard_id  = validate( params, required: false, var: 'dashboardIds', type: Integer )
+      folder_id     = validate( params, required: false, var: 'folderIds'   , type: Integer )
+      starred       = validate( params, required: false, var: 'starred'     , type: Boolean )
+      limit         = validate( params, required: false, var: 'limit'       , type: Integer )
+
+      unless(type.nil?)
+        valid_types   = ['dash-folder', 'dash-db']
+        downcased = Set.new valid_types.map(&:downcase)
+        return { 'status' => 404, 'message' => format( 'wrong type. Must be one of %s, given \'%s\'', valid_types.join(', '), type ) } unless( downcased.include?( type.downcase ) )
+      end
+
+      api     = []
+      api << format( 'query=%s', CGI.escape( query ) ) unless( query.nil? )
+      api << format( 'tags=%s', tag ) unless( tag.nil? )
+      api << format( 'type=%s', type ) unless( type.nil? )
+      api << format( 'dashboardId=%s', dashboard_id ) unless( dashboard_id.nil? )
+      api << format( 'folderId=%s', folder_id ) unless( folder_id.nil? )
+      api << format( 'starred=%s', starred ) unless( starred.nil? )
+      api << format( 'limit=%s', limit ) unless( limit.nil? )
+
+      api = api.join( '&' )
+
+      endpoint = format('/api/search?%s', api)
+      get(endpoint)
+    end
+
+  end
+end
+

data/lib/grafana/folder_permissions.rb

@@ -0,0 +1,155 @@
+module Grafana
+
+  # http://docs.grafana.org/http_api/folder_permissions/#folder-permissions-api
+  #
+  # This API can be used to update/get the permissions for a folder.
+  #
+  # Permissions with folderId=-1 are the default permissions for users with the Viewer and Editor roles.
+  # Permissions can be set for a user, a team or a role (Viewer or Editor).
+  # Permissions cannot be set for Admins - they always have access to everything.
+  #
+  # The permission levels for the permission field:
+  #
+  # 1 = View
+  # 2 = Edit
+  # 4 = Admin
+  #
+  module FolderPermissions
+
+    # Get permissions for a folder
+    # GET /api/folders/:uid/permissions
+    #
+    # Gets all existing permissions for the folder with the given uid.
+    def folder_permissions( folder_id )
+
+      v, mv = version.values
+      return { 'status' => 404, 'message' => format( 'folder has been supported in Grafana since version 5. you use version %s', v) } if(mv < 5)
+
+      f = folder( folder_id )
+
+      status = f.dig('status')
+      return f if( status != 200 )
+
+      endpoint = format('/api/folders/%s/permissions', f.dig('uid') )
+
+      @logger.debug("Getting all folders (GET #{endpoint})") if @debug
+      get(endpoint)
+    end
+
+
+    # Update permissions for a folder
+    # POST /api/folders/:uid/permissions
+    #
+    # Updates permissions for a folder.
+    # This operation will remove existing permissions if they're not included in the request.
+    #
+    # JSON body schema:
+    #
+    # items - The permission items to add/update. Items that are omitted from the list will be removed.
+    #
+    def update_folder_permissions( 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? )
+
+      v, mv = version.values
+      return { 'status' => 404, 'message' => format( 'folder has been supported in Grafana since version 5. you use version %s', v) } if(mv < 5)
+
+      folder      = validate( params, required: true, var: 'folder'     , type: String )
+      permissions = validate( params, required: true, var: 'permissions', type: Hash )
+
+      return { 'status' => 404, 'message' => 'no permissions given' } if( permissions.size.zero? )
+
+      f_folder = folder(folder)
+      return { 'status' => 404, 'message' => format( 'No Folder \'%s\' found', folder) } if( f_folder.dig('status') != 200 )
+
+      folder_uid = f_folder.dig('uid')
+
+      valid_roles = %w[View Edit Admin]
+#       valid_keys  = %w[role permission teamId userId]
+
+      c_team = permissions.dig('team')
+      c_user = permissions.dig('user')
+      team   = []
+      user   = []
+
+      unless(c_team.nil?)
+        check_keys = []
+
+        c_team.uniq.each do |x|
+          k = x.keys.first
+          v = x.values.first
+          r = validate_hash( v, valid_roles )
+
+          f_team = team(k)
+          team_id = f_team.dig('id')
+
+          next unless(( f_team.dig('status') == 200) && !check_keys.include?(team_id) && r == true )
+
+          check_keys << team_id
+
+          role_id = valid_roles.index(v)
+          role_id += 1
+          role_id += 1 if(v == 'Admin')
+
+          team << {
+            teamId: team_id,
+            permission: role_id
+          }
+        end
+      end
+
+      unless(c_user.nil?)
+        check_keys = []
+
+        c_user.uniq.each do |x|
+          k = x.keys.first
+          v = x.values.first
+          r = validate_hash( v, valid_roles )
+
+          f_user = user(k)
+          user_id = f_user.dig('id')
+
+          next unless(( f_user.dig('status') == 200) && !check_keys.include?(user_id) && r == true )
+
+          check_keys << user_id
+
+          role_id = valid_roles.index(v)
+          role_id += 1
+          role_id += 1 if(v == 'Admin')
+
+          user << {
+            userId: user_id,
+            permission: role_id
+          }
+        end
+      end
+
+      payload = {
+        items: team + user
+      }
+      payload.reject!{ |_, y| y.nil? }
+
+      endpoint = format( '/api/folders/%s/permissions', folder_uid )
+
+      post(endpoint, payload.to_json)
+    end
+
+
+#    private
+#    def validate_hash( value, valid_params )
+#
+#      downcased = Set.new valid_params.map(&:downcase)
+#
+#      unless( downcased.include?( value.downcase ) )
+#        return {
+#          'status' => 404,
+#          'message' => format( 'wrong permissions. Must be one of %s, given \'%s\'', valid_params.join(', '), value )
+#        }
+#      end
+#      true
+#    end
+
+  end
+end
+

data/lib/grafana/logging.rb

@@ -0,0 +1,55 @@
+
+require 'logger'
+
+# -------------------------------------------------------------------------------------------------
+
+module Logging
+
+  def logger
+    @logger ||= Logging.logger_for( self.class.name )
+  end
+
+  # Use a hash class-ivar to cache a unique Logger per class:
+  @loggers = {}
+
+  class << self
+
+    def logger_for( classname )
+      @loggers[classname] ||= configure_logger_for( classname )
+    end
+
+    def configure_logger_for( classname )
+
+      log_level = ENV.fetch('LOG_LEVEL', 'INFO' )
+      level = log_level.dup
+
+      # DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN
+      log_level = case level.upcase
+        when 'DEBUG'
+          Logger::DEBUG   # Low-level information for developers.
+        when 'INFO'
+          Logger::INFO    # Generic (useful) information about system operation.
+        when 'WARN'
+          Logger::WARN    # A warning.
+        when 'ERROR'
+          Logger::ERROR   # A handleable error condition.
+        when 'FATAL'
+          Logger::FATAL   # An unhandleable error that results in a program crash.
+        else
+          Logger::UNKNOWN  # An unknown message that should always be logged.
+        end
+
+      $stdout.sync           = true
+      logger                 = Logger.new($stdout)
+      logger.level           = log_level
+      logger.datetime_format = "%Y-%m-%d %H:%M:%S %z"
+      logger.formatter       = proc do |severity, datetime, progname, msg|
+        "[#{datetime.strftime( logger.datetime_format )}] #{severity.ljust(5)}  #{msg}\n"
+      end
+
+      logger
+    end
+  end
+end
+
+# -------------------------------------------------------------------------------------------------

data/lib/grafana/login.rb

@@ -29,20 +29,27 @@ module Grafana
       max_retries = validate( params, required: false, var: 'max_retries', type: Integer ) || 2
       sleep_between_retries = validate( params, required: false, var: 'sleep_between_retries', type: Integer ) || 5
 
-      begin
-        @api_instance = RestClient::Resource.new(
-          @url,
-          timeout: @timeout.to_i,
-          open_timeout: @open_timeout.to_i,
-          headers: @http_headers,
-          verify_ssl: false
-        )
-      rescue => e
-        logger.error( e ) if @debug
-        logger.debug( e.backtrace.join("\n") ) if @debug
-        false
+      # raise 'no valid rest instance found' if( @api_instance.nil? )
+
+      # only useful for Grafana version < 6
+      #
+      if( @api_instance.nil? )
+
+        @api_user = username
+        @api_password = password
+
+        @api_instance = create_instance
+
+        return true if(@api_instance)
+      else
+        logger.debug('User session already initiated') if @debug
+        return true
       end
 
+      logger.debug( "resource: #{@api_instance.inspect}")
+
+      false
+
       request_data = { 'User' => username, 'Password' => password }
 
       if( @api_instance )
@@ -51,13 +58,15 @@ module Grafana
         @headers          = {}
 
         begin
-          logger.debug('Attempting to establish user session') if @debug
+          logger.debug('Attempting to establish user session') # if @debug
 
-          response = @api_instance['/login'].post(
+          response = @api_instance['/api/login'].post(
             request_data.to_json,
             content_type: 'application/json; charset=UTF-8'
           )
 
+          logger.debug( "response #{response}")
+
           response_cookies  = response.cookies
           response_code     = response.code.to_i
 
@@ -67,58 +76,59 @@ module Grafana
               accept: 'application/json',
               cookies: response_cookies
             }
+            @username = username
+            @password = password
           end
 
         rescue SocketError
-          if( retried < max_retries )
-            retried += 1
-            logger.debug( format( 'cannot login, socket error (retry %d / %d)', retried, max_retries ) ) if @debug
-            sleep( sleep_between_retries )
-            retry
-          else
-            raise format( 'Maximum retries (%d) against \'%s/login\' reached. Giving up ...', max_retries, @url )
-          end
+          raise format( 'Maximum retries (%d) against \'%s/login\' reached. Giving up ...', max_retries, @url ) unless( retried < max_retries )
+
+          retried += 1
+          logger.debug( format( 'cannot login, socket error (retry %d / %d)', retried, max_retries ) ) if @debug
+          sleep( sleep_between_retries )
+          retry
 
         rescue RestClient::Unauthorized
           logger.debug( request_data.to_json ) if @debug
           raise format( 'Not authorized to connect \'%s\' - wrong username or password?', @url )
 
         rescue RestClient::BadGateway
-          if( retried < max_retries )
-            retried += 1
-            logger.debug( format( 'cannot login, connection refused (retry %d / %d)', retried, max_retries ) ) if @debug
-            sleep( sleep_between_retries )
-            retry
-          else
-            raise format( 'Maximum retries (%d) against \'%s/login\' reached. Giving up ...', max_retries, @url )
-          end
+          raise format( 'Maximum retries (%d) against \'%s/login\' reached. Giving up ...', max_retries, @url ) unless( retried < max_retries )
+
+          retried += 1
+          logger.debug( format( 'cannot login, connection refused (retry %d / %d)', retried, max_retries ) ) if @debug
+          sleep( sleep_between_retries )
+          retry
 
         rescue Errno::ECONNREFUSED
-          if( retried < max_retries )
-            retried += 1
-            logger.debug( format( 'cannot login, connection refused (retry %d / %d)', retried, max_retries ) ) if @debug
-            sleep( sleep_between_retries )
-            retry
-          else
-            raise format( 'Maximum retries (%d) against \'%s/login\' reached. Giving up ...', max_retries, @url )
-          end
+          raise format( 'Maximum retries (%d) against \'%s/login\' reached. Giving up ...', max_retries, @url ) unless( retried < max_retries )
+
+          retried += 1
+          logger.debug( format( 'cannot login, connection refused (retry %d / %d)', retried, max_retries ) ) if @debug
+          sleep( sleep_between_retries )
+          retry
 
         rescue Errno::EHOSTUNREACH
-          if( retried < max_retries )
-            retried += 1
-            logger.debug( format( 'cannot login, host unreachable (retry %d / %d)', retried, max_retries ) ) if @debug
-            sleep( sleep_between_retries )
-            retry
-          else
-            raise format( 'Maximum retries (%d) against \'%s/login\' reached. Giving up ...', max_retries, @url )
-          end
+          raise format( 'Maximum retries (%d) against \'%s/login\' reached. Giving up ...', max_retries, @url ) unless( retried < max_retries )
+
+          retried += 1
+          logger.debug( format( 'cannot login, host unreachable (retry %d / %d)', retried, max_retries ) ) if @debug
+          sleep( sleep_between_retries )
+          retry
+
+        rescue => error
+          raise format( 'Maximum retries (%d) against \'%s/login\' reached. Giving up ...', max_retries, @url ) unless( retried < max_retries )
+
+          retried += 1
+          logger.error( error )
+          logger.debug( format( 'cannot login (retry %d / %d)', retried, max_retries ) ) if @debug
+          sleep( sleep_between_retries )
+          retry
         end
 
         logger.debug('User session initiated') if @debug
-
         return true
       end
-
       false
     end
 
@@ -132,7 +142,41 @@ module Grafana
     def ping_session
       endpoint = '/api/login/ping'
       logger.debug( "Pinging current session (GET #{endpoint})" ) if @debug
-      get( endpoint )
+
+      begin
+        get( endpoint )
+      rescue => error
+        logger.error(e)
+      end
+    end
+
+    # Returns health information about Grafana
+    #
+    # @example
+    #    health
+    #
+    # @return [Hash]
+    #
+    def health
+      endpoint = '/api/health'
+      logger.debug( "get health information (GET #{endpoint})" ) if @debug
+
+      result = get( endpoint )
+
+      if( result.is_a?(Hash) )
+        status = result.dig('status')
+        if( status.to_i == 200 )
+          message = result.dig('message')
+          r = message.gsub('=>', ':').gsub(':nil,', ':null,')
+          return { 'status' => status, 'message' => JSON.parse( r ) }
+        end
+      end
+
+      result
+    end
+
+    def headers
+      @headers
     end
   end