App42_Ruby_API 0.8.4

data/lib/log/Log.rb

@@ -0,0 +1,49 @@
+# -----------------------------------------------------------------------
+#  Copyright © 2012 ShepHertz Technologies Pvt Ltd. All rights reserved.
+# -----------------------------------------------------------------------
+
+require 'App42_Ruby_API/App42Response'
+
+#
+#
+# This Log object is the value object which contains the properties of Log.
+#
+#
+
+module App42
+  module Log
+    class Log < App42Response
+      attr_accessor  :messageList
+      @messageList = Array.new
+    end
+
+    class  Message
+      attr_accessor  :message,:type,:logTime,:module
+
+      #
+      # This is a constructor that takes no parameter
+      #
+      #
+      def initialize(log)
+        log.messageList.push(self);
+      end
+
+      #
+      # Returns the Log Response in JSON format.
+      #
+      # @return the response in JSON format.
+      #
+      #
+
+      def to_s
+        return "Message : #{self.message}" + "type : #{self.type}" + "AppModule : #{self.module}" + "logTime : #{self.logTime}";
+      end
+
+      @message
+      @type
+      @logTime
+      @module
+
+    end
+  end
+end

data/lib/log/LogResponseBuilder.rb

@@ -0,0 +1,61 @@
+# -----------------------------------------------------------------------
+#  Copyright © 2012 ShepHertz Technologies Pvt Ltd. All rights reserved.
+# -----------------------------------------------------------------------
+
+require 'json/pure'
+require 'App42_Ruby_API/App42ResponseBuilder'
+require 'log/Log'
+
+module App42
+  module Log
+    #
+    #
+    # LogResponseBuilder class converts the JSON response retrieved from the server
+    # to the value object i.e Log
+    #
+    #
+    class LogResponseBuilder < App42ResponseBuilder
+      #
+      # Converts the response in JSON format to the value object i.e Log
+      #
+      # @param json
+      #      - response in JSON format
+      #
+      # @return Log object filled with json data
+      #
+      #
+      def buildResponse(json)
+        puts "testing #{json}"
+        logObj = Log.new()
+        messageList = Array.new
+        logObj.messageList= messageList
+        logObj.strResponse=json
+        jsonObj = JSON.parse(json)
+        jsonObjApp42 = jsonObj.fetch("app42")
+        jsonObjResponse = jsonObjApp42.fetch("response")
+        logObj.isResponseSuccess = jsonObjResponse.fetch("success")
+        jsonObjLog = jsonObjResponse["logs"]
+        if jsonObjLog.key?("log") == false
+          return logObj;
+        end
+
+        if  jsonObjLog.fetch("log").instance_of?(Hash)
+          # Only One attribute is there
+          jsonObjLogMessage = jsonObjLog.fetch("log")
+          messageItem = App42::Log::Message.new(logObj)
+          buildObjectFromJSONTree(messageItem, jsonObjLogMessage);
+        else
+          jsonObjMessageArray = jsonObjLog.fetch("log")
+          # There is an Array of attribute
+          jsonObjMessageArray.length.times do |i|
+            # Get Individual Attribute Node and set it into Object
+            jsonObjLogMessage = jsonObjMessageArray[i]
+            messageItem = App42::Log::Message.new(logObj)
+            buildObjectFromJSONTree(messageItem, jsonObjLogMessage);
+          end
+        end
+        return logObj;
+      end
+    end
+  end
+end

data/lib/log/LogService.rb

@@ -0,0 +1,920 @@
+# -----------------------------------------------------------------------
+#  Copyright © 2012 ShepHertz Technologies Pvt Ltd. All rights reserved.
+# -----------------------------------------------------------------------
+
+require 'rubygems'
+require 'connection/RESTConnection'
+require 'util/util'
+require 'json/pure'
+require 'App42_Ruby_API/App42Response'
+require 'log/LogResponseBuilder'
+require 'log/Log'
+
+module App42
+  module Log
+    #
+    # Centralize logging for your App. This service allows different levels e.g. info,
+    # debug, fatal, error etc. to log a message and query the messages based on
+    # different parameters.
+    #
+    # You can fetch logs based on module, level, message, date range etc.
+    #
+    # @see Log
+    #
+    class LogService
+      #
+      # this is a constructor that takes
+      #
+      # @param apiKey
+      # @param secretKey
+      # @param baseURL
+      #
+      def initialize(api_key, secret_key, base_url)
+        puts "LogService->initialize"
+        @api_key = api_key
+        @secret_key = secret_key
+        @base_url = base_url
+        @resource = "log"
+        @version = "1.0"
+      end
+
+      #
+      # Builds and Logs the message
+      #
+      # @param msg
+      #      - Message to be logged
+      # @param module
+      #      - Module name for which the message is getting logged
+      # @param level
+      #      - The level on which the message is getting logged
+      #
+      # @return Log object containing logged message
+      #
+      # @throws App42Exception
+      #
+
+      def build_and_send(msg,appModule,level)
+        puts "Build and Send Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        logObj = nil
+        logObj = Log.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(msg, "Message");
+        util.throwExceptionIfNullOrBlank(appModule, "App Module");
+        util.throwExceptionIfNullOrBlank(appModule, "Level");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          body = {'app42' => {"log"=> {
+            "message" => msg,
+            "appModule" => appModule
+            }}}.to_json
+          puts "Body #{body}"
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc
+          }
+          query_params = params.clone
+          params.store("body", body)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/#{level}"
+          response = connection.post(signature, resource_url, query_params, body)
+          log = LogResponseBuilder.new()
+          logObj  = log.buildResponse(response);
+        rescue  App42Exception =>e
+          puts e
+          raise e
+        rescue  Exception => e
+          puts e
+          raise App42Exception.new(e)
+        end
+        return logObj
+      end
+
+      #
+      # Logs the info message
+      #
+      # @param msg
+      #      - Message to be logged
+      # @param module
+      #      - Module name for which the message is getting logged
+      #
+      # @return Log object containing logged message
+      #
+      # @raise App42Exception
+      #
+
+      def info( msg,  appModule)
+        return build_and_send(msg, appModule, "info");
+      end
+
+      #
+      # Logs the debug message
+      #
+      # @param msg
+      #      - Message to be logged
+      # @param module
+      #      - Module name for which the message is getting logged
+      #
+      # @return Log object containing logged message
+      #
+      # @raise App42Exception
+      #
+
+      def debug( msg,  appModule)
+        return build_and_send(msg, appModule, "debug");
+      end
+
+      #
+      # Logs the fatal message
+      #
+      # @param msg
+      #      - Message to be logged
+      # @param module
+      #      - Module name for which the message is getting logged
+      #
+      # @return Log object containing logged message
+      #
+      # @raise App42Exception
+      #
+
+      def fatal( msg,  appModule)
+        return build_and_send(msg, appModule, "fatal");
+      end
+
+      #
+      # Logs the error message
+      #
+      # @param msg
+      #      - Message to be logged
+      # @param module
+      #      - Module name for which the message is getting logged
+      #
+      # @return Log object containing  logged message
+      #
+      # @raise App42Exception
+      #
+
+      def error( msg,  appModule)
+        return build_and_send(msg, appModule, "error");
+      end
+
+      #
+      # Fetch the log messages based on the Module
+      #
+      # @param moduleName
+      #      - Module name for which the messages has to be fetched
+      #
+      # @return Log object containing fetched messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_by_module(moduleName)
+        puts "Fetch Logs By Module Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        logObj = nil
+        logObj = Log.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(moduleName, "ModuleName");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("moduleName", moduleName)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/module/#{moduleName}"
+          response = connection.get(signature, resource_url, query_params)
+          puts "Response is #{response}"
+          logObj = LogResponseBuilder.new().buildResponse(response);
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return logObj
+      end
+
+      #
+      # Fetch the log messages based on the Module by paging.
+      #
+      # @param moduleName
+      #      - Module name for which the messages has to be fetched
+      # @param max
+      #      - Maximum number of records to be fetched
+      # @param offset
+      #      - From where the records are to be fetched
+      #
+      # @return Log object containing fetched messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_by_module_by_paging(moduleName, max, offset)
+        puts "Fetch Logs By Module By Paging Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        logObj = nil
+        logObj = Log.new
+        util = Util.new
+        util.validateMax(max);
+        util.throwExceptionIfNullOrBlank(moduleName, "ModuleName");
+        util.throwExceptionIfNullOrBlank(max, "Max");
+        util.throwExceptionIfNullOrBlank(offset, "Offset");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("moduleName", moduleName)
+          params.store("max", "" + (max.to_i).to_s)
+          params.store("offset", "" + (offset.to_i).to_s)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/paging/module/#{moduleName}/#{(max.to_i).to_s}/#{(offset.to_i).to_s}"
+          response = connection.get(signature, resource_url, query_params)
+          logObj = LogResponseBuilder.new().buildResponse(response);
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        puts logObj
+        return logObj
+      end
+
+      #
+      # Fetch log messages based on the Module and Message Text
+      #
+      # @param moduleName
+      #      - Module name for which the messages has to be fetched
+      # @param text
+      #      - The log message on which logs have to be searched
+      #
+      # @return Log object containing fetched messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_by_module_and_text(moduleName, text)
+        puts "Fetch Logs By Module And Text Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        logObj = nil
+        logObj = Log.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(moduleName, "ModuleName");
+        util.throwExceptionIfNullOrBlank(text, "Text");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("moduleName", moduleName)
+          params.store("text", text)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/module/#{moduleName}/text/#{text}"
+          response = connection.get(signature, resource_url, query_params)
+          logObj = LogResponseBuilder.new().buildResponse(response);
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return logObj
+      end
+
+      #
+      # Fetch log messages based on the Module and Message Text by paging.
+      #
+      # @param moduleName
+      #      - Module name for which the messages has to be fetched
+      # @param text
+      #      - The log message on which logs have to be searched
+      # @param max
+      #      - Maximum number of records to be fetched
+      # @param offset
+      #      - From where the records are to be fetched
+      #
+      # @return Log object containing fetched messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_by_module_and_text_by_paging(moduleName, text, max, offset)
+        puts "Fetch Logs By Module And Text By Paging Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        logObj = nil
+        logObj = Log.new
+        util = Util.new
+        util.validateMax(max);
+        util.throwExceptionIfNullOrBlank(moduleName, "ModuleName");
+        util.throwExceptionIfNullOrBlank(text, "Text");
+        util.throwExceptionIfNullOrBlank(max, "Max");
+        util.throwExceptionIfNullOrBlank(offset, "Offset");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("moduleName", moduleName)
+          params.store("text", text)
+          params.store("max", "" + (max.to_i).to_s)
+          params.store("offset", "" + (offset.to_i).to_s)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/paging/module/#{moduleName}/text/#{text}/#{(max.to_i).to_s}/#{(offset.to_i).to_s}"
+          response = connection.get(signature, resource_url, query_params)
+          logObj = LogResponseBuilder.new().buildResponse(response);
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return logObj
+      end
+
+      #
+      # Fetch the log messages based on the Level
+      #
+      # @param level
+      #      - The level on which logs have to be searched
+      #
+      # @return Log object containing fetched messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_by_level(level)
+        puts "Fetch Logs By Leve Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        logObj = nil
+        logObj = Log.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(level, "Level");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("type", level)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/type/#{level}"
+          response = connection.get(signature, resource_url, query_params)
+          logObj = LogResponseBuilder.new().buildResponse(response);
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return logObj
+      end
+
+      #
+      # Fetch the log messages based on the Level by paging.
+      #
+      # @param level
+      #      - The level on which logs have to be searched
+      # @param max
+      #      - Maximum number of records to be fetched
+      # @param offset
+      #      - From where the records are to be fetched
+      #
+      # @return Log object containing fetched messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_by_level_by_paging(level, max, offset)
+        puts "Fetch Logs By Level By Paging Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        logObj = nil
+        logObj = Log.new
+        util = Util.new
+        util.validateMax(max);
+        util.throwExceptionIfNullOrBlank(level, "Level");
+        util.throwExceptionIfNullOrBlank(max, "Max");
+        util.throwExceptionIfNullOrBlank(offset, "Offset");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("type", level)
+          params.store("max", "" + (max.to_i).to_s)
+          params.store("offset", "" + (offset.to_i).to_s)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/paging/type/#{level}/#{(max.to_i).to_s}/#{(offset.to_i).to_s}"
+          response = connection.get(signature, resource_url, query_params)
+          logObj = LogResponseBuilder.new().buildResponse(response);
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return logObj
+      end
+
+      #
+      # Fetch log messages based on Info Level
+      #
+      # @return Log object containing fetched info messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_by_info()
+        return fetch_logs_by_level("INFO");
+      end
+
+      #
+      # Fetch log messages based on Info Level by paging.
+      #
+      # @param max
+      #      - Maximum number of records to be fetched
+      # @param offset
+      #      - From where the records are to be fetched
+      #
+      # @return Log object containing fetched info messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_by_info_by_paging(max, offset)
+        return fetch_logs_by_level_by_paging("INFO", max, offset);
+      end
+
+      #
+      # Fetch log messages based on Debug Level by paging.
+      #
+      # @param max
+      #      - Maximum number of records to be fetched
+      # @param offset
+      #      - From where the records are to be fetched
+      #
+      # @return Log object containing fetched debug messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_by_debug_by_paging(max, offset)
+        return fetch_logs_by_level_by_paging("DEBUG", max, offset);
+      end
+
+      #
+      # Fetch log messages based on Error Level by paging.
+      #
+      # @param max
+      #      - Maximum number of records to be fetched
+      # @param offset
+      #      - From where the records are to be fetched
+      #
+      # @return Log object containing fetched error messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_by_error_by_paging(max, offset)
+        return fetch_logs_by_level_by_paging("ERROR", max, offset);
+      end
+
+      #
+      # Fetch log messages based on Fatal Level by paging.
+      #
+      # @param max
+      #      - Maximum number of records to be fetched
+      # @param offset
+      #      - From where the records are to be fetched
+      #
+      # @return Log object containing fetched Fatal messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_by_fatal_by_paging(max, offset)
+        return fetch_logs_by_level_by_paging("FATAL", max, offset);
+      end
+
+      #
+      # Fetch log messages based on Date range by paging.
+      #
+      # @param startDate
+      #      - Start date from which the log messages have to be fetched
+      # @param endDate
+      #      - End date upto which the log messages have to be fetched
+      # @param max
+      #      - Maximum number of records to be fetched
+      # @param offset
+      #      - From where the records are to be fetched
+      #
+      # @return Log object containing fetched messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_log_by_date_range_by_paging(startDate, endDate, max, offset)
+        puts "Fetch Logs By Date Range By Paging Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        logObj = nil
+        logObj = Log.new
+        util = Util.new
+        util.validateMax(max);
+        util.throwExceptionIfNullOrBlank(max, "Max");
+        util.throwExceptionIfNullOrBlank(offset, "Offset");
+        util.throwExceptionIfNullOrBlank(startDate, "Start Date");
+        util.throwExceptionIfNullOrBlank(endDate, "End Date");
+        strStartdate = util.get_timestamp_utc_from_date(startDate)
+        strEnddate = util.get_timestamp_utc_from_date(endDate)
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+
+          strStartDate = util.get_timestamp_utc_from_date(startDate);
+          strEndDate = util.get_timestamp_utc_from_date(endDate);
+          params.store("startDate", strStartdate)
+          params.store("endDate", strEnddate)
+          params.store("max", "" + (max.to_i).to_s)
+          params.store("offset", "" + (offset.to_i).to_s)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/paging/startDate/#{strStartdate}/endDate/#{strEnddate}/#{(max.to_i).to_s}/#{(offset.to_i).to_s}"
+          response = connection.get(signature, resource_url, query_params)
+          logObj = LogResponseBuilder.new().buildResponse(response);
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return logObj
+      end
+
+      #
+      # Fetch log messages based on Debug Level
+      #
+      # @return Log object containing fetched debug messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_by_debug()
+        return fetch_logs_by_level("DEBUG");
+      end
+
+      #
+      # Fetch log messages based on Error Level
+      #
+      # @return Log object containing fetched error messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_by_error()
+        return fetch_logs_by_level("ERROR");
+      end
+
+      #
+      # Fetch log messages based on Fatal Level
+      #
+      # @return Log object containing fetched Fatal messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_by_fatal()
+        return fetch_logs_by_level("FATAL");
+      end
+
+      #
+      # Fetch log messages based on Date range
+      #
+      # @param startDate
+      #      - Start date from which the log messages have to be fetched
+      # @param endDate
+      #      - End date upto which the log messages have to be fetched
+      #
+      # @return Log object containing fetched messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_log_by_date_range(startDate, endDate)
+        puts "Fetch Logs By Date Range Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        logObj = nil
+        logObj = Log.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(startDate, "Start Date");
+        util.throwExceptionIfNullOrBlank(endDate, "End Date");
+        strStartdate = util.get_timestamp_utc_from_date(startDate)
+        strEnddate = util.get_timestamp_utc_from_date(endDate)
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          strStartDate = util.get_timestamp_utc_from_date(startDate);
+          strEndDate = util.get_timestamp_utc_from_date(endDate);
+          params.store("startDate", strStartdate)
+          params.store("endDate", strEnddate)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/startDate/#{strStartdate}/endDate/#{strEnddate}"
+          response = connection.get(signature, resource_url, query_params)
+          logObj = LogResponseBuilder.new().buildResponse(response);
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return logObj
+      end
+
+      #
+      # Fetch the count of log messages based on the Module
+      #
+      # @param moduleName
+      #      - Module name for which the count of messages has to be fetched
+      #
+      # @return App42Response object containing count of fetched messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_count_by_module(moduleName)
+        puts "Fetch Logs Count By Module Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        responseObj = App42Response.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(moduleName, "ModuleName");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("moduleName", moduleName)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/module/#{moduleName}/count"
+          response = connection.get(signature, resource_url, query_params)
+          responseObj.strResponse=(response)
+          responseObj.isResponseSuccess=(true)
+          responseObj = LogResponseBuilder.new()
+          responseObj.getTotalRecords(response);
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return responseObj
+      end
+
+      #
+      # Fetch count of log messages based on the Module and Message Text
+      #
+      # @param moduleName
+      #      - Module name for which the count of messages has to be fetched
+      # @param text
+      #      - The log message on which count of logs have to be searched
+      #
+      # @return App42Response object containing count of fetched messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_count_by_module_and_text(moduleName, text)
+        puts "Fetch Logs Count By Module And Text Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        responseObj = App42Response.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(moduleName, "ModuleName");
+        util.throwExceptionIfNullOrBlank(text, "Text");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("moduleName", moduleName)
+          params.store("text", text);
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/module/#{moduleName}/text/#{text}/count"
+          response = connection.get(signature, resource_url, query_params)
+          puts "Response is #{response}"
+          responseObj.strResponse=(response)
+          responseObj.isResponseSuccess=(true)
+          responseObj = LogResponseBuilder.new()
+          responseObj.getTotalRecords(response);
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return responseObj
+      end
+
+      #
+      # Fetch the count of log messages based on the Level
+      #
+      # @param level
+      #      - The level on which count of logs have to be searched
+      #
+      # @return App42Response object containing count of fetched messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_count_by_level(level)
+        puts "Fetch Logs Count By Level Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        responseObj = App42Response.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(level, "Level");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("type", level)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/type/#{level}/count"
+          response = connection.get(signature, resource_url, query_params)
+          puts "Response is #{response}"
+          responseObj.strResponse=(response)
+          responseObj.isResponseSuccess=(true)
+          responseObj = LogResponseBuilder.new()
+          responseObj.getTotalRecords(response);
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return responseObj
+      end
+
+      #
+      # Fetch count of log messages based on Info Level
+      #
+      # @return App42Response object containing count of fetched info messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_count_by_info()
+        return fetch_logs_count_by_level("INFO");
+      end
+
+      #
+      # Fetch count of log messages based on Debug Level
+      #
+      # @return App42Response object containing count of fetched debug messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_count_by_debug()
+        return fetch_logs_count_by_level("DEBUG");
+      end
+
+      #
+      # Fetch count of log messages based on Error Level
+      #
+      # @return App42Response object containing  count of fetched error messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_count_by_error()
+        return fetch_logs_count_by_level("ERROR");
+      end
+
+      #
+      # Fetch count of log messages based on Fatal Level
+      #
+      # @return App42Response object containing count of fetched Fatal messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_count_by_fatal()
+        return fetch_logs_count_by_level("FATAL");
+      end
+
+      #
+      # Fetch count of log messages based on Date range
+      #
+      # @param startDate
+      #      - Start date from which the count of log messages have to be fetched
+      # @param endDate
+      #      - End date upto which the count of log messages have to be fetched
+      #
+      # @return App42Response object containing count of fetched messages
+      #
+      # @raise App42Exception
+      #
+
+      def fetch_logs_count_by_date_range(startDate, endDate)
+        puts "Fetch Logs Count By Date Range Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        responseObj = App42Response.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(startDate, "Start Date");
+        util.throwExceptionIfNullOrBlank(endDate, "End Date");
+        strStartdate = util.get_timestamp_utc_from_date(startDate)
+        strEnddate = util.get_timestamp_utc_from_date(endDate)
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          strStartDate = util.get_timestamp_utc_from_date(startDate);
+          strEndDate = util.get_timestamp_utc_from_date(endDate);
+          params.store("startDate", strStartdate)
+          params.store("endDate", strEnddate)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/startDate/#{strStartdate}/endDate/#{strEnddate}/count"
+          response = connection.get(signature, resource_url, query_params)
+          responseObj.strResponse=(response)
+          responseObj.isResponseSuccess=(true)
+          responseObj = LogResponseBuilder.new()
+          responseObj.getTotalRecords(response);
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return responseObj
+      end
+
+    end
+  end
+end