vmware_web_service 2.1.1 → 3.0.0

data/lib/VMwareWebService/MiqVimPerfHistory.rb

@@ -1,6 +1,9 @@
 require 'date'
+require 'VMwareWebService/logging'
 
 class MiqVimPerfHistory
+  include VMwareWebService::Logging
+
   attr_reader :invObj
 
   def initialize(invObj)
@@ -95,9 +98,9 @@ class MiqVimPerfHistory
   end
 
   def queryProviderSummary(mor)
-    $vim_log.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).queryProviderSummary: calling queryPerfProviderSummary" if $vim_log
+    logger.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).queryProviderSummary: calling queryPerfProviderSummary"
     psum = @invObj.queryPerfProviderSummary(@perfManager, mor)
-    $vim_log.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).queryProviderSummary: returned from queryPerfProviderSummary" if $vim_log
+    logger.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).queryProviderSummary: returned from queryPerfProviderSummary"
     (psum)
   end
 
@@ -108,9 +111,9 @@ class MiqVimPerfHistory
       beginTime  = ah[:beginTime] || nil
       endTime    = ah[:endTime] || nil
     end
-    $vim_log.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).availMetricsForEntity: calling queryAvailablePerfMetric" if $vim_log
+    logger.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).availMetricsForEntity: calling queryAvailablePerfMetric"
     pmids = @invObj.queryAvailablePerfMetric(@perfManager, mor, beginTime, endTime, intervalId)
-    $vim_log.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).availMetricsForEntity: returned from queryAvailablePerfMetric" if $vim_log
+    logger.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).availMetricsForEntity: returned from queryAvailablePerfMetric"
     (pmids)
   end
 
@@ -121,9 +124,9 @@ class MiqVimPerfHistory
     ah[:entity]     = entnty
     pqs             = getPerfQuerySpec(ah)
 
-    $vim_log.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).queryPerf: calling queryPerf" if $vim_log
+    logger.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).queryPerf: calling queryPerf"
     umPem = @invObj.queryPerf(@perfManager, pqs)[0]
-    $vim_log.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).queryPerf: returned from queryPerf" if $vim_log
+    logger.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).queryPerf: returned from queryPerf"
 
     #
     # Construct an array of (timestamp, value) pairs.
@@ -151,9 +154,9 @@ class MiqVimPerfHistory
       aa.each { |ah| pqsa << getPerfQuerySpec(ah) }
     end
 
-    $vim_log.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).queryPerfMulti: calling queryPerf" if $vim_log
+    logger.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).queryPerfMulti: calling queryPerf"
     pema = @invObj.queryPerf(@perfManager, querySpec)
-    $vim_log.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).queryPerfMulti: returned from queryPerf" if $vim_log
+    logger.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).queryPerfMulti: returned from queryPerf"
 
     return(nil) unless pema
 
@@ -165,9 +168,9 @@ class MiqVimPerfHistory
     ah[:entity]     = entnty
     pqs             = getPerfQuerySpec(ah)
 
-    $vim_log.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).queryPerfComposite: calling queryPerfComposite" if $vim_log
+    logger.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).queryPerfComposite: calling queryPerfComposite"
     umPem = @invObj.queryPerfComposite(@perfManager, pqs)
-    $vim_log.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).queryPerfComposite: returned from queryPerfComposite" if $vim_log
+    logger.info "MiqVimPerfHistory(#{@invObj.server}, #{@invObj.username}).queryPerfComposite: returned from queryPerfComposite"
 
     umPem['childEntity'] = [umPem['childEntity']] if umPem['childEntity'].kind_of? Hash
 

data/lib/VMwareWebService/MiqVimUpdate.rb

@@ -27,9 +27,9 @@ module MiqVimUpdate
 
     while truncated
       begin
-        $vim_log.info "#{log_prefix}: call to waitForUpdates...Starting" if $vim_log
+        logger.info "#{log_prefix}: call to waitForUpdates...Starting"
         updateSet = waitForUpdatesEx(@umPropCol, version, wait_options)
-        $vim_log.info "#{log_prefix}: call to waitForUpdates...Complete" if $vim_log
+        logger.info "#{log_prefix}: call to waitForUpdates...Complete"
 
         version   = updateSet.version
         truncated = updateSet.truncated
@@ -46,7 +46,7 @@ module MiqVimUpdate
         # Help out the Ruby Garbage Collector by resetting variables pointing to large objects back to nil
         updateSet = nil
       rescue HTTPClient::ReceiveTimeoutError => terr
-        $vim_log.info "#{log_prefix}: call to waitForUpdates...Timeout" if $vim_log
+        logger.info "#{log_prefix}: call to waitForUpdates...Timeout"
         raise terr if !isAlive?
         retry
       end
@@ -58,9 +58,9 @@ module MiqVimUpdate
   def monitorUpdatesSince(version)
     log_prefix = "MiqVimUpdate.monitorUpdatesSince (#{@connId})"
     begin
-      $vim_log.info "#{log_prefix}: call to waitForUpdates...Starting (version = #{version})" if $vim_log
+      logger.info "#{log_prefix}: call to waitForUpdates...Starting (version = #{version})"
       updateSet = waitForUpdatesEx(@umPropCol, version, :max_wait => @maxWait)
-      $vim_log.info "#{log_prefix}: call to waitForUpdates...Complete (version = #{version})" if $vim_log
+      logger.info "#{log_prefix}: call to waitForUpdates...Complete (version = #{version})"
       return version if updateSet.nil?
 
       version = updateSet.version
@@ -70,11 +70,11 @@ module MiqVimUpdate
       updateSet.filterSet.each do |fu|
         next if fu.filter != @filterSpecRef
         fu.objectSet.each do |objUpdate|
-          $vim_log.info "#{log_prefix}: applying update...Starting (version = #{version})" if $vim_log
+          logger.info "#{log_prefix}: applying update...Starting (version = #{version})"
           @cacheLock.synchronize(:EX) do
             updateObject(objUpdate)
           end
-          $vim_log.info "#{log_prefix}: applying update...Complete (version = #{version})" if $vim_log
+          logger.info "#{log_prefix}: applying update...Complete (version = #{version})"
           Thread.pass
         end
       end # updateSet.filterSet.each
@@ -82,9 +82,9 @@ module MiqVimUpdate
       updateSet = nil
       return version
     rescue HTTPClient::ReceiveTimeoutError => terr
-      $vim_log.info "#{log_prefix}: call to waitForUpdates...Timeout (version = #{version})" if $vim_log
+      logger.info "#{log_prefix}: call to waitForUpdates...Timeout (version = #{version})"
       retry if isAlive?
-      $vim_log.warn "#{log_prefix}: connection lost"
+      logger.warn "#{log_prefix}: connection lost"
       raise terr
     end
   end
@@ -97,7 +97,7 @@ module MiqVimUpdate
     @debugUpdates   = false if @debugUpdates.nil?
     @dumpToLog      = true  if @debugUpdates
 
-    $vim_log.debug "#{log_prefix}: debugUpdates = #{@debugUpdates}"
+    logger.debug "#{log_prefix}: debugUpdates = #{@debugUpdates}"
 
     begin
       @umPropCol     = @sic.propertyCollector
@@ -116,18 +116,18 @@ module MiqVimUpdate
       # Ignore signals, except TERM
     rescue => herr
       if herr.respond_to?(:reason) && herr.reason == 'The task was canceled by a user.'
-        $vim_log.info "#{log_prefix}: waitForUpdates canceled"
+        logger.info "#{log_prefix}: waitForUpdates canceled"
       else
-        $vim_log.error "******* #{herr.class}"
-        $vim_log.error herr.to_s
-        $vim_log.error herr.backtrace.join("\n") unless herr.kind_of?(HTTPClient::ReceiveTimeoutError) # already logged in monitorUpdatesInitial or monitorUpdatesSince
+        logger.error "******* #{herr.class}"
+        logger.error herr.to_s
+        logger.error herr.backtrace.join("\n") unless herr.kind_of?(HTTPClient::ReceiveTimeoutError) # already logged in monitorUpdatesInitial or monitorUpdatesSince
         raise herr
       end
     ensure
       if @filterSpecRef && isAlive?
-        $vim_log.info "#{log_prefix}: calling destroyPropertyFilter...Starting"
+        logger.info "#{log_prefix}: calling destroyPropertyFilter...Starting"
         destroyPropertyFilter(@filterSpecRef)
-        $vim_log.info "#{log_prefix}: calling destroyPropertyFilter...Complete"
+        logger.info "#{log_prefix}: calling destroyPropertyFilter...Complete"
       end
       @filterSpecRef = nil
       # @umPropCol     = nil
@@ -137,18 +137,18 @@ module MiqVimUpdate
   def stopUpdateMonitor
     log_prefix = "MiqVimUpdate.stopUpdateMonitor (#{@connId})"
 
-    $vim_log.info "#{log_prefix}: for address=<#{@server}>, username=<#{@username}>...Starting"
+    logger.info "#{log_prefix}: for address=<#{@server}>, username=<#{@username}>...Starting"
     @monitor = false
     if @umPropCol
       if isAlive?
-        $vim_log.info "#{log_prefix}: calling cancelWaitForUpdates...Starting"
+        logger.info "#{log_prefix}: calling cancelWaitForUpdates...Starting"
         cancelWaitForUpdates(@umPropCol)
-        $vim_log.info "#{log_prefix}: calling cancelWaitForUpdates...Complete"
+        logger.info "#{log_prefix}: calling cancelWaitForUpdates...Complete"
       end
       @umPropCol = nil
       @updateThread.run if @updateThread.status == "sleep"
     end
-    $vim_log.info "#{log_prefix}: for address=<#{@server}>, username=<#{@username}>...Complete"
+    logger.info "#{log_prefix}: for address=<#{@server}>, username=<#{@username}>...Complete"
   end
 
   def forceFail
@@ -159,7 +159,7 @@ module MiqVimUpdate
   def updateObject(objUpdate, initialUpdate = false)
     unless @inventoryHash # no cache to update
       return unless initialUpdate
-      $vim_log.info "MiqVimUpdate.updateObject: setting @inventoryHash to empty hash"
+      logger.info "MiqVimUpdate.updateObject: setting @inventoryHash to empty hash"
       @inventoryHash = {}
     end
 
@@ -171,12 +171,12 @@ module MiqVimUpdate
     when 'modify'
       updateProps(objUpdate, initialUpdate)
     else
-      $vim_log.warn "MiqVimUpdate.updateObject (#{@connId}): unrecognized operation: #{objUpdate.kind}"
+      logger.warn "MiqVimUpdate.updateObject (#{@connId}): unrecognized operation: #{objUpdate.kind}"
     end
   end
 
   def updateProps(objUpdate, initialUpdate = false)
-    $vim_log.debug "Update object (#{@connId}): #{objUpdate.obj.vimType}: #{objUpdate.obj}" if @debugUpdates
+    logger.debug "Update object (#{@connId}): #{objUpdate.obj.vimType}: #{objUpdate.obj}" if @debugUpdates
     return if !objUpdate.changeSet || objUpdate.changeSet.empty?
 
     #
@@ -191,7 +191,7 @@ module MiqVimUpdate
     hashName = "#{pm[:baseName]}ByMor"
     return unless (objHash = instance_variable_get(hashName)) # no cache to update
     unless (obj = objHash[objUpdate.obj])
-      $vim_log.warn "updateProps (#{@connId}): object #{objUpdate.obj} not found in #{hashName}"
+      logger.warn "updateProps (#{@connId}): object #{objUpdate.obj} not found in #{hashName}"
       return
     end
 
@@ -234,8 +234,8 @@ module MiqVimUpdate
       # Call the notify callback if enabled, defined and we are past the initial update
       #
       if @notifyMethod && !initialUpdate
-        $vim_log.debug "MiqVimUpdate.updateProps (#{@connId}): server = #{@server}, mor = (#{objUpdate.obj.vimType}, #{objUpdate.obj})"
-        $vim_log.debug "MiqVimUpdate.updateProps (#{@connId}): changedProps = [ #{changedProps.join(', ')} ]"
+        logger.debug "MiqVimUpdate.updateProps (#{@connId}): server = #{@server}, mor = (#{objUpdate.obj.vimType}, #{objUpdate.obj})"
+        logger.debug "MiqVimUpdate.updateProps (#{@connId}): changedProps = [ #{changedProps.join(', ')} ]"
         Thread.new do
           @notifyMethod.call(:server       => @server,
                              :username     => @username,
@@ -251,9 +251,9 @@ module MiqVimUpdate
       end
 
     rescue => err
-      $vim_log.warn "MiqVimUpdate::updateProps (#{@connId}): #{err}"
-      $vim_log.warn "Clearing cache for (#{@connId}): #{pm[:baseName]}"
-      $vim_log.debug err.backtrace.join("\n")
+      logger.warn "MiqVimUpdate::updateProps (#{@connId}): #{err}"
+      logger.warn "Clearing cache for (#{@connId}): #{pm[:baseName]}"
+      logger.debug err.backtrace.join("\n")
       dumpCache("#{pm[:baseName]}ByMor")
 
       instance_variable_set("#{pm[:baseName]}ByMor", nil)
@@ -266,9 +266,9 @@ module MiqVimUpdate
     objBaseType = objUpdate.obj.vimBaseType
 
     # always log additions to the inventory.
-    $vim_log.info "MiqVimUpdate.addObject (#{@connId}): #{objType}: #{objUpdate.obj}"
+    logger.info "MiqVimUpdate.addObject (#{@connId}): #{objType}: #{objUpdate.obj}"
     return unless (pm = @propMap[objBaseType.to_sym])  # not an object type we cache
-    $vim_log.info "MiqVimUpdate.addObject (#{@connId}): Adding object #{objType}: #{objUpdate.obj}"
+    logger.info "MiqVimUpdate.addObject (#{@connId}): Adding object #{objType}: #{objUpdate.obj}"
 
     #
     # First, add the object's MOR to the @inventoryHash entry for the object's type.
@@ -283,7 +283,7 @@ module MiqVimUpdate
       hashName = "#{pm[:baseName]}ByMor"
       unless instance_variable_get(hashName) # no cache to update
         return unless initialUpdate
-        $vim_log.info "MiqVimUpdate.addObject: setting #{hashName} and #{pm[:baseName]} to empty hash"
+        logger.info "MiqVimUpdate.addObject: setting #{hashName} and #{pm[:baseName]} to empty hash"
         instance_variable_set(hashName, {})
         instance_variable_set(pm[:baseName], {})
       end
@@ -298,7 +298,7 @@ module MiqVimUpdate
       # Call the notify callback if enabled, defined and we are past the initial update
       #
       if @notifyMethod && !initialUpdate
-        $vim_log.debug "MiqVimUpdate.addObject: server = #{@server}, mor = (#{objUpdate.obj.vimType}, #{objUpdate.obj})"
+        logger.debug "MiqVimUpdate.addObject: server = #{@server}, mor = (#{objUpdate.obj.vimType}, #{objUpdate.obj})"
         Thread.new do
           @notifyMethod.call(:server   => @server,
                              :username => @username,
@@ -310,9 +310,9 @@ module MiqVimUpdate
       end
 
     rescue => err
-      $vim_log.warn "MiqVimUpdate::addObject: #{err}"
-      $vim_log.warn "Clearing cache for: #{pm[:baseName]}"
-      $vim_log.debug err.backtrace.join("\n")
+      logger.warn "MiqVimUpdate::addObject: #{err}"
+      logger.warn "Clearing cache for: #{pm[:baseName]}"
+      logger.debug err.backtrace.join("\n")
       dumpCache("#{pm[:baseName]}ByMor")
 
       instance_variable_set("#{pm[:baseName]}ByMor", nil)
@@ -325,9 +325,9 @@ module MiqVimUpdate
     objBaseType = objUpdate.obj.vimBaseType
 
     # always log deletions from the inventory.
-    $vim_log.info "MiqVimUpdate.deleteObject (#{@connId}): #{objType}: #{objUpdate.obj}"
+    logger.info "MiqVimUpdate.deleteObject (#{@connId}): #{objType}: #{objUpdate.obj}"
     return unless (pm = @propMap[objBaseType.to_sym])      # not an object type we cache
-    $vim_log.info "MiqVimUpdate.deleteObject (#{@connId}): Deleting object: #{objType}: #{objUpdate.obj}"
+    logger.info "MiqVimUpdate.deleteObject (#{@connId}): Deleting object: #{objType}: #{objUpdate.obj}"
 
     ia = @inventoryHash[objType]
     ia.delete(objUpdate.obj)
@@ -341,7 +341,7 @@ module MiqVimUpdate
       # Call the notify callback if enabled, defined and we are past the initial update
       #
       if @notifyMethod && !initialUpdate
-        $vim_log.debug "MiqVimUpdate.deleteObject: server = #{@server}, mor = (#{objUpdate.obj.vimType}, #{objUpdate.obj})"
+        logger.debug "MiqVimUpdate.deleteObject: server = #{@server}, mor = (#{objUpdate.obj.vimType}, #{objUpdate.obj})"
         Thread.new do
           @notifyMethod.call(:server   => @server,
                              :username => @username,
@@ -353,9 +353,9 @@ module MiqVimUpdate
       end
 
     rescue => err
-      $vim_log.warn "MiqVimUpdate::deleteObject: #{err}"
-      $vim_log.warn "Clearing cache for: #{pm[:baseName]}"
-      $vim_log.debug err.backtrace.join("\n")
+      logger.warn "MiqVimUpdate::deleteObject: #{err}"
+      logger.warn "Clearing cache for: #{pm[:baseName]}"
+      logger.debug err.backtrace.join("\n")
       dumpCache("#{pm[:baseName]}ByMor")
 
       instance_variable_set("#{pm[:baseName]}ByMor", nil)
@@ -367,17 +367,17 @@ module MiqVimUpdate
     changedProps = [] if returnChangedProps
     changeSet.each do |propChange|
       if @debugUpdates
-        $vim_log.debug "\tpropChange name (path): #{propChange.name}"
-        $vim_log.debug "\tpropChange op: #{propChange.op}"
-        $vim_log.debug "\tpropChange val (type): #{propChange.val.class}"
+        logger.debug "\tpropChange name (path): #{propChange.name}"
+        logger.debug "\tpropChange op: #{propChange.op}"
+        logger.debug "\tpropChange val (type): #{propChange.val.class}"
 
-        $vim_log.debug "\t*** propChange val START:"
+        logger.debug "\t*** propChange val START:"
         oGi = @globalIndent
         @globalIndent = "\t\t"
         dumpObj(propChange.val)
         @globalIndent = oGi
-        $vim_log.debug "\t*** propChange val END"
-        $vim_log.debug "\t***"
+        logger.debug "\t*** propChange val END"
+        logger.debug "\t***"
       end
 
       #
@@ -424,9 +424,9 @@ module MiqVimUpdate
 
   def dumpCache(cache)
     return unless @debugUpdates
-    $vim_log.debug "**** Dumping #{cache} cache"
+    logger.debug "**** Dumping #{cache} cache"
     dumbObj(instance_variable_get(cache))
-    $vim_log.debug "**** #{cache} dump end"
+    logger.debug "**** #{cache} dump end"
   end
   private :dumpCache
 

data/lib/VMwareWebService/MiqVimVdlMod.rb

@@ -5,9 +5,9 @@ module MiqVimVdlConnectionMod
   #
   def vdlConnection
     require 'VMwareWebService/VixDiskLib/VixDiskLib'
-    VixDiskLib.init(->(s) { $vim_log.info  "VMware(VixDiskLib): #{s}" },
-                    ->(s) { $vim_log.warn  "VMware(VixDiskLib): #{s}" },
-                    ->(s) { $vim_log.error "VMware(VixDiskLib): #{s}" })
+    VixDiskLib.init(->(s) { logger.info  "VMware(VixDiskLib): #{s}" },
+                    ->(s) { logger.warn  "VMware(VixDiskLib): #{s}" },
+                    ->(s) { logger.error "VMware(VixDiskLib): #{s}" })
     $log.info "MiqVimVdlConnectionMod.vdlConnection: server - #{@server}"
     VixDiskLib.connect(:serverName => server,
                        :port       => 902,
@@ -17,7 +17,7 @@ module MiqVimVdlConnectionMod
   end
 
   def closeVdlConnection(connection)
-    $vim_log.info "MiqVimMod.closeVdlConnection: #{connection.serverName}"
+    logger.info "MiqVimMod.closeVdlConnection: #{connection.serverName}"
     connection.disconnect
   end
 end # module MiqVimVdlConnectionMod
@@ -31,9 +31,9 @@ module MiqVimVdlVcConnectionMod
   def vdlVcConnection
     require 'VMwareWebService/VixDiskLib/VixDiskLib'
 
-    VixDiskLib.init(->(s) { $vim_log.info  "VMware(VixDiskLib): #{s}" },
-                    ->(s) { $vim_log.warn  "VMware(VixDiskLib): #{s}" },
-                    ->(s) { $vim_log.error "VMware(VixDiskLib): #{s}" })
+    VixDiskLib.init(->(s) { logger.info  "VMware(VixDiskLib): #{s}" },
+                    ->(s) { logger.warn  "VMware(VixDiskLib): #{s}" },
+                    ->(s) { logger.error "VMware(VixDiskLib): #{s}" })
 
     $log.info "MiqVimVdlVcConnectionMod.vdlVcConnection: server - #{invObj.server}"
     thumb_print = if invObj.isVirtualCenter?

data/lib/VMwareWebService/MiqVimVm.rb

@@ -1,17 +1,18 @@
 require 'sync'
 
-require 'enumerator'
 require "ostruct"
 
 require 'more_core_extensions/core_ext/hash'
 require 'active_support/core_ext/object/try'
 
 require 'VMwareWebService/exception'
+require 'VMwareWebService/logging'
 require 'VMwareWebService/MiqVimVdlMod'
 require 'VMwareWebService/esx_thumb_print'
 require 'VMwareWebService/vcenter_thumb_print'
 
 class MiqVimVm
+  include VMwareWebService::Logging
   include MiqVimVdlVcConnectionMod
 
   EVM_SNAPSHOT_NAME         = "EvmSnapshot".freeze # TODO: externalize - not VIM specific
@@ -92,53 +93,53 @@ class MiqVimVm
   #######################
 
   def start(wait = true)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).start: calling powerOnVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).start: calling powerOnVM_Task"
     taskMor = @invObj.powerOnVM_Task(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).start: returned from powerOnVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).start: returned from powerOnVM_Task"
     return taskMor unless wait
     waitForTask(taskMor)
   end # def start
 
   def stop(wait = true)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).stop: calling powerOffVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).stop: calling powerOffVM_Task"
     taskMor = @invObj.powerOffVM_Task(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).stop: returned from powerOffVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).stop: returned from powerOffVM_Task"
     return taskMor unless wait
     waitForTask(taskMor)
   end # def stop
 
   def suspend(wait = true)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).suspend: calling suspendVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).suspend: calling suspendVM_Task"
     taskMor = @invObj.suspendVM_Task(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).suspend: returned from suspendVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).suspend: returned from suspendVM_Task"
     return taskMor unless wait
     waitForTask(taskMor)
   end # def suspend
 
   def reset(wait = true)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).reset: calling resetVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).reset: calling resetVM_Task"
     taskMor = @invObj.resetVM_Task(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).reset: returned from resetVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).reset: returned from resetVM_Task"
     return taskMor unless wait
     waitForTask(taskMor)
   end
 
   def rebootGuest
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).rebootGuest: calling rebootGuest" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).rebootGuest: calling rebootGuest"
     @invObj.rebootGuest(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).rebootGuest: returned from rebootGuest" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).rebootGuest: returned from rebootGuest"
   end
 
   def shutdownGuest
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).shutdownGuest: calling shutdownGuest" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).shutdownGuest: calling shutdownGuest"
     @invObj.shutdownGuest(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).shutdownGuest: returned from shutdownGuest" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).shutdownGuest: returned from shutdownGuest"
   end
 
   def standbyGuest
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).standbyGuest: calling standbyGuest" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).standbyGuest: calling standbyGuest"
     @invObj.standbyGuest(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).standbyGuest: returned from standbyGuest" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).standbyGuest: returned from standbyGuest"
   end
 
   def powerState
@@ -168,18 +169,18 @@ class MiqVimVm
   ############################
 
   def markAsTemplate
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).markAsTemplate: calling markAsTemplate" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).markAsTemplate: calling markAsTemplate"
     @invObj.markAsTemplate(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).markAsTemplate: returned from markAsTemplate" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).markAsTemplate: returned from markAsTemplate"
   end
 
   def markAsVm(pool, host = nil)
     hmor = nil
     hmor = (host.kind_of?(Hash) ? host['MOR'] : host) if host
     pmor = (pool.kind_of?(Hash) ? pool['MOR'] : pool)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).markAsVm: calling markAsVirtualMachine" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).markAsVm: calling markAsVirtualMachine"
     @invObj.markAsVirtualMachine(@vmMor, pmor, hmor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).markAsVm: returned from markAsVirtualMachine" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).markAsVm: returned from markAsVirtualMachine"
   end
 
   def template?
@@ -194,18 +195,18 @@ class MiqVimVm
     hmor = (host.kind_of?(Hash) ? host['MOR'] : host)
     pool = (pool.kind_of?(Hash) ? pool['MOR'] : pool) if pool
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).migrate: calling migrateVM_Task, vm=<#{@vmMor.inspect}>, host=<#{hmor.inspect}>, pool=<#{pool.inspect}>, priority=<#{priority.inspect}>, state=<#{state.inspect}>" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).migrate: calling migrateVM_Task, vm=<#{@vmMor.inspect}>, host=<#{hmor.inspect}>, pool=<#{pool.inspect}>, priority=<#{priority.inspect}>, state=<#{state.inspect}>"
     taskMor = @invObj.migrateVM_Task(@vmMor, pool, hmor, priority, state)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).migrate: returned from migrateVM_Task" if $vim_log
-    $vim_log.debug "MiqVimVm::migrate: taskMor = #{taskMor}" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).migrate: returned from migrateVM_Task"
+    logger.debug "MiqVimVm::migrate: taskMor = #{taskMor}"
     waitForTask(taskMor)
   end
 
   def renameVM(newName)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).renameVM: calling rename_Task, vm=<#{@vmMor.inspect}>, newName=<#{newName}>" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).renameVM: calling rename_Task, vm=<#{@vmMor.inspect}>, newName=<#{newName}>"
     task_mor = @invObj.rename_Task(@vmMor, newName)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).renameVM: returned from rename_Task" if $vim_log
-    $vim_log.debug "MiqVimVm::renameVM: taskMor = #{task_mor}" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).renameVM: returned from rename_Task"
+    logger.debug "MiqVimVm::renameVM: taskMor = #{task_mor}"
     waitForTask(task_mor)
   end
 
@@ -223,26 +224,26 @@ class MiqVimVm
       rsl.transform    = transform      if transform
     end
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).relocate: calling relocateVM_Task, vm=<#{@vmMor.inspect}>, host=<#{hmor.inspect}>, pool=<#{pool.inspect}>, datastore=<#{dsmor.inspect}>, priority=<#{priority.inspect}>" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).relocate: calling relocateVM_Task, vm=<#{@vmMor.inspect}>, host=<#{hmor.inspect}>, pool=<#{pool.inspect}>, datastore=<#{dsmor.inspect}>, priority=<#{priority.inspect}>"
     taskMor = @invObj.relocateVM_Task(@vmMor, rspec, priority)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).relocate: returned from relocateVM_Task" if $vim_log
-    $vim_log.debug "MiqVimVm::relocate: taskMor = #{taskMor}" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).relocate: returned from relocateVM_Task"
+    logger.debug "MiqVimVm::relocate: taskMor = #{taskMor}"
     waitForTask(taskMor)
   end
 
   def cloneVM_raw(folder, name, spec, wait = true)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).cloneVM_raw: calling cloneVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).cloneVM_raw: calling cloneVM_Task"
     taskMor = @invObj.cloneVM_Task(@vmMor, folder, name, spec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).cloneVM_raw: returned from cloneVM_Task" if $vim_log
-    $vim_log.debug "MiqVimVm::cloneVM_raw: taskMor = #{taskMor}" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).cloneVM_raw: returned from cloneVM_Task"
+    logger.debug "MiqVimVm::cloneVM_raw: taskMor = #{taskMor}"
 
     if wait
       rv = waitForTask(taskMor)
-      $vim_log.debug "MiqVimVm::cloneVM_raw: rv = #{rv}" if $vim_log
+      logger.debug "MiqVimVm::cloneVM_raw: rv = #{rv}"
       return rv
     end
 
-    $vim_log.debug "MiqVimVm::cloneVM_raw - no wait: taskMor = #{taskMor}" if $vim_log
+    logger.debug "MiqVimVm::cloneVM_raw - no wait: taskMor = #{taskMor}"
     taskMor
   end
 
@@ -288,15 +289,15 @@ class MiqVimVm
   # end
 
   def unregister
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).unregister: calling unregisterVM" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).unregister: calling unregisterVM"
     @invObj.unregisterVM(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).unregister: returned from unregisterVM" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).unregister: returned from unregisterVM"
   end
 
   def destroy
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).destroy: calling destroy_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).destroy: calling destroy_Task"
     taskMor = @invObj.destroy_Task(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).destroy: returned from destroy_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).destroy: returned from destroy_Task"
     waitForTask(taskMor)
   end
 
@@ -378,33 +379,33 @@ class MiqVimVm
   end
 
   def createSnapshot(name, desc, memory, quiesce, wait = true, free_space_percent = 100)
-    $vim_log.debug "MiqVimVm::createSnapshot(#{name}, #{desc}, #{memory}, #{quiesce})" if $vim_log
+    logger.debug "MiqVimVm::createSnapshot(#{name}, #{desc}, #{memory}, #{quiesce})"
     cs = connectionState
     raise "MiqVimVm(#{@invObj.server}, #{@invObj.username}).createSnapshot: VM is not connected, connectionState = #{cs}" if cs != "connected"
     snapshot_free_space_check('create', free_space_percent)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).createSnapshot: calling createSnapshot_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).createSnapshot: calling createSnapshot_Task"
     taskMor = @invObj.createSnapshot_Task(@vmMor, name, desc, memory, quiesce)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).createSnapshot: returned from createSnapshot_Task" if $vim_log
-    $vim_log.debug "MiqVimVm::createSnapshot: taskMor = #{taskMor}" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).createSnapshot: returned from createSnapshot_Task"
+    logger.debug "MiqVimVm::createSnapshot: taskMor = #{taskMor}"
 
     if wait
       snMor = waitForTask(taskMor)
-      $vim_log.warn "MiqVimVm::createSnapshot: snMor = #{snMor}" if $vim_log
+      logger.warn "MiqVimVm::createSnapshot: snMor = #{snMor}"
       return snMor
     end
 
-    $vim_log.debug "MiqVimVm::createSnapshot - no wait: taskMor = #{taskMor}" if $vim_log
+    logger.debug "MiqVimVm::createSnapshot - no wait: taskMor = #{taskMor}"
     taskMor
   end # def createSnapshot
 
   def removeSnapshot(snMor, subTree = "false", wait = true, free_space_percent = 100)
-    $vim_log.warn "MiqVimVm::removeSnapshot(#{snMor}, #{subTree})" if $vim_log
+    logger.warn "MiqVimVm::removeSnapshot(#{snMor}, #{subTree})"
     snMor = getSnapMor(snMor)
     snapshot_free_space_check('remove', free_space_percent)
-    $vim_log.warn "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeSnapshot: calling removeSnapshot_Task: snMor [#{snMor}] subtree [#{subTree}]" if $vim_log
+    logger.warn "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeSnapshot: calling removeSnapshot_Task: snMor [#{snMor}] subtree [#{subTree}]"
     taskMor = @invObj.removeSnapshot_Task(snMor, subTree)
-    $vim_log.warn "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeSnapshot: returned from removeSnapshot_Task: snMor [#{snMor}]" if $vim_log
-    $vim_log.debug "MiqVimVm::removeSnapshot: taskMor = #{taskMor}" if $vim_log
+    logger.warn "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeSnapshot: returned from removeSnapshot_Task: snMor [#{snMor}]"
+    logger.debug "MiqVimVm::removeSnapshot: taskMor = #{taskMor}"
     return taskMor unless wait
     waitForTask(taskMor)
   end # def removeSnapshot
@@ -422,40 +423,40 @@ class MiqVimVm
   end # def removeSnapshotByDescription
 
   def removeAllSnapshots(free_space_percent = 100)
-    $vim_log.debug "MiqVimVm::removeAllSnapshots" if $vim_log
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeAllSnapshots: calling removeAllSnapshots_Task" if $vim_log
+    logger.debug "MiqVimVm::removeAllSnapshots"
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeAllSnapshots: calling removeAllSnapshots_Task"
     snapshot_free_space_check('remove_all', free_space_percent)
     taskMor = @invObj.removeAllSnapshots_Task(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeAllSnapshots: returned from removeAllSnapshots_Task" if $vim_log
-    $vim_log.debug "MiqVimVm::removeAllSnapshots: taskMor = #{taskMor}" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeAllSnapshots: returned from removeAllSnapshots_Task"
+    logger.debug "MiqVimVm::removeAllSnapshots: taskMor = #{taskMor}"
     waitForTask(taskMor)
   end # def removeAllSnapshots
 
   def revertToSnapshot(snMor)
-    $vim_log.debug "MiqVimVm::revertToSnapshot(#{snMor})" if $vim_log
+    logger.debug "MiqVimVm::revertToSnapshot(#{snMor})"
     snMor = getSnapMor(snMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).revertToSnapshot: calling revertToSnapshot_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).revertToSnapshot: calling revertToSnapshot_Task"
     taskMor = @invObj.revertToSnapshot_Task(snMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).revertToSnapshot: returned from revertToSnapshot_Task" if $vim_log
-    $vim_log.debug "MiqVimVm::revertToSnapshot: taskMor = #{taskMor}" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).revertToSnapshot: returned from revertToSnapshot_Task"
+    logger.debug "MiqVimVm::revertToSnapshot: taskMor = #{taskMor}"
     waitForTask(taskMor)
   end # def revertToSnapshot
 
   def revertToCurrentSnapshot
-    $vim_log.debug "MiqVimVm::revertToCurrentSnapshot" if $vim_log
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).revertToCurrentSnapshot: calling revertToCurrentSnapshot_Task" if $vim_log
+    logger.debug "MiqVimVm::revertToCurrentSnapshot"
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).revertToCurrentSnapshot: calling revertToCurrentSnapshot_Task"
     taskMor = @invObj.revertToCurrentSnapshot_Task(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).revertToCurrentSnapshot: returned from revertToCurrentSnapshot_Task" if $vim_log
-    $vim_log.debug "MiqVimVm::revertToCurrentSnapshot: taskMor = #{taskMor}" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).revertToCurrentSnapshot: returned from revertToCurrentSnapshot_Task"
+    logger.debug "MiqVimVm::revertToCurrentSnapshot: taskMor = #{taskMor}"
     waitForTask(taskMor)
   end # def revertToCurrentSnapshot
 
   def renameSnapshot(snMor, name, desc)
-    $vim_log.debug "MiqVimVm::renameSnapshot(#{snMor}, #{name}, #{desc})" if $vim_log
+    logger.debug "MiqVimVm::renameSnapshot(#{snMor}, #{name}, #{desc})"
     snMor = getSnapMor(snMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).renameSnapshot: calling renameSnapshot" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).renameSnapshot: calling renameSnapshot"
     @invObj.renameSnapshot(snMor, name, desc)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).renameSnapshot: returned from renameSnapshot" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).renameSnapshot: returned from renameSnapshot"
   end # def renameSnapshot
 
   def snapshot_free_space_check(action, free_space_percent = 100)
@@ -509,13 +510,13 @@ class MiqVimVm
 
   def getSnapMor(snMor)
     unless snMor.respond_to?(:vimType)
-      $vim_log.debug "MiqVimVm::getSnapMor converting #{snMor} to MOR" if $vim_log
+      logger.debug "MiqVimVm::getSnapMor converting #{snMor} to MOR"
       @cacheLock.synchronize(:SH) do
         raise "getSnapMor: VM #{@dsPath} has no snapshots" unless (sni = snapshotInfo_locked(true))
         raise "getSnapMor: snapshot #{snMor} not found" unless (snObj = sni['ssMorHash'][snMor])
         snMor = snObj['snapshot']
       end
-      $vim_log.debug "MiqVimVm::getSnapMor new MOR: #{snMor}" if $vim_log
+      logger.debug "MiqVimVm::getSnapMor new MOR: #{snMor}"
     end
     (snMor)
   end # def getSnapMor
@@ -610,9 +611,9 @@ class MiqVimVm
   end # def getCfg
 
   def reconfig(vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).reconfig: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).reconfig: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).reconfig: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).reconfig: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end
 
@@ -631,9 +632,9 @@ class MiqVimVm
 
   def setMemory(memMB)
     vmConfigSpec = VimHash.new("VirtualMachineConfigSpec") { |cs| cs.memoryMB = memMB }
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setMemory: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setMemory: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setMemory: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setMemory: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end
 
@@ -643,9 +644,9 @@ class MiqVimVm
 
   def setNumCPUs(numCPUs)
     vmConfigSpec = VimHash.new("VirtualMachineConfigSpec") { |cs| cs.numCPUs = numCPUs }
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setNumCPUs: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setNumCPUs: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setNumCPUs: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setNumCPUs: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end
 
@@ -667,9 +668,9 @@ class MiqVimVm
       end
     end
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).connectDevice: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).connectDevice: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).connectDevice: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).connectDevice: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end # def connectDevice
 
@@ -705,9 +706,9 @@ class MiqVimVm
       end
     end
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).attachIsoToCd: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).attachIsoToCd: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).attachIsoToCd: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).attachIsoToCd: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end
 
@@ -723,9 +724,9 @@ class MiqVimVm
       end
     end
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).resetCd: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).resetCd: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).resetCd: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).resetCd: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end
 
@@ -803,9 +804,9 @@ class MiqVimVm
       end
     end
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).addDisk: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).addDisk: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).addDisk: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).addDisk: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end # def addDisk
 
@@ -820,8 +821,8 @@ class MiqVimVm
     raise "removeDiskByFile: false setting for deleteBacking not yet supported" if deleteBacking == false
     controllerKey, key = getDeviceKeysByBacking(backingFile)
     raise "removeDiskByFile: no virtual device associated with: #{backingFile}" unless key
-    $vim_log.debug "MiqVimVm::MiqVimVm: backingFile = #{backingFile}" if $vim_log
-    $vim_log.debug "MiqVimVm::MiqVimVm: controllerKey = #{controllerKey}, key = #{key}" if $vim_log
+    logger.debug "MiqVimVm::MiqVimVm: backingFile = #{backingFile}"
+    logger.debug "MiqVimVm::MiqVimVm: controllerKey = #{controllerKey}, key = #{key}"
 
     vmConfigSpec = VimHash.new("VirtualMachineConfigSpec") do |vmcs|
       vmcs.deviceChange = VimArray.new("ArrayOfVirtualDeviceConfigSpec") do |vmcs_vca|
@@ -859,9 +860,9 @@ class MiqVimVm
       end
     end
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeDiskByFile: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeDiskByFile: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeDiskByFile: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeDiskByFile: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end # def removeDiskByFile
 
@@ -869,7 +870,7 @@ class MiqVimVm
     disk = getDeviceByBacking(backingFile)
     raise "resizeDisk: no virtual device associated with: #{backingFile}" unless disk
     raise "resizeDisk: cannot reduce the size of a disk" unless newSizeInKb >= Integer(disk.capacityInKB)
-    $vim_log.debug "MiqVimVm::resizeDisk: backingFile = #{backingFile} current size = #{device.capacityInKB} newSize = #{newSizeInKb} KB" if $vim_log
+    logger.debug "MiqVimVm::resizeDisk: backingFile = #{backingFile} current size = #{device.capacityInKB} newSize = #{newSizeInKb} KB"
 
     vmConfigSpec = VimHash.new("VirtualMachineConfigSpec") do |vmcs|
       vmcs.deviceChange = VimArray.new("ArrayOfVirtualDeviceConfigSpec") do |vmcs_vca|
@@ -887,9 +888,9 @@ class MiqVimVm
       end
     end
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).resizeDisk: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).resizeDisk: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).resizeDisk: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).resizeDisk: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end
 
@@ -1041,9 +1042,9 @@ class MiqVimVm
       else
         aSpec = @miqAlarmSpecDisabled
       end
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).addMiqAlarm_locked: calling createAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).addMiqAlarm_locked: calling createAlarm"
       alarmMor = @invObj.createAlarm(alarmManager, @vmMor, aSpec)
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).addMiqAlarm_locked: returned from createAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).addMiqAlarm_locked: returned from createAlarm"
       @miqAlarmMor = alarmMor
     ensure
       @cacheLock.sync_unlock if unlock
@@ -1074,9 +1075,9 @@ class MiqVimVm
     begin
       @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
 
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).getMiqAlarm_locked: calling getAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).getMiqAlarm_locked: calling getAlarm"
       alarms = @invObj.getAlarm(@sic.alarmManager, @vmMor)
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).getMiqAlarm_locked: returned from getAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).getMiqAlarm_locked: returned from getAlarm"
       alarms.each do |aMor|
         ap = @invObj.getMoProp(aMor, "info.name")
         next unless ap['info']['name'][MIQ_ALARM_PFX]
@@ -1105,27 +1106,27 @@ class MiqVimVm
   def disableMiqAlarm
     @cacheLock.synchronize(:SH) do
       raise "disableMiqAlarm: MiqAlarm not configured for VM #{@dsPath}" unless (aMor = getMiqAlarm_locked)
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).disableMiqAlarm: calling reconfigureAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).disableMiqAlarm: calling reconfigureAlarm"
       @invObj.reconfigureAlarm(aMor, @miqAlarmSpecDisabled)
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).disableMiqAlarm: returned from reconfigureAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).disableMiqAlarm: returned from reconfigureAlarm"
     end
   end
 
   def enableMiqAlarm
     @cacheLock.synchronize(:SH) do
       raise "enableMiqAlarm: MiqAlarm not configured for VM #{@dsPath}" unless (aMor = getMiqAlarm_locked)
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).enableMiqAlarm: calling reconfigureAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).enableMiqAlarm: calling reconfigureAlarm"
       @invObj.reconfigureAlarm(aMor, @miqAlarmSpecEnabled)
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).enableMiqAlarm: returned from reconfigureAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).enableMiqAlarm: returned from reconfigureAlarm"
     end
   end
 
   def removeMiqAlarm
     @cacheLock.synchronize(:SH) do
       return unless (aMor = getMiqAlarm_locked)
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeMiqAlarm: calling removeAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeMiqAlarm: calling removeAlarm"
       @invObj.removeAlarm(aMor)
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeMiqAlarm: returned from removeAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeMiqAlarm: returned from removeAlarm"
       @miqAlarmMor = nil
     end
   end
@@ -1177,9 +1178,9 @@ class MiqVimVm
       end
     end
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setExtraConfigAttributes: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setExtraConfigAttributes: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setExtraConfigAttributes: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setExtraConfigAttributes: returned from reconfigVM_Task"
     waitForTask(taskMor)
 
     @extraConfig = nil
@@ -1287,16 +1288,16 @@ class MiqVimVm
   end
 
   def acquireMksTicket
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).acquireMksTicket: calling acquireMksTicket" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).acquireMksTicket: calling acquireMksTicket"
     rv = @invObj.acquireMksTicket(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).acquireMksTicket: returned from acquireMksTicket" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).acquireMksTicket: returned from acquireMksTicket"
     (rv)
   end # def acquireMksTicket
 
   def acquireTicket(ticketType)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).acquireTicket: calling acquireTicket" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).acquireTicket: calling acquireTicket"
     rv = @invObj.acquireTicket(@vmMor, ticketType)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).acquireTicket: returned from acquireTicket" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).acquireTicket: returned from acquireTicket"
     (rv)
   end # def acquireTicket