dnsruby 1.1 → 1.2

data/README

@@ -10,8 +10,7 @@ resolv.rb Resolv API, but has been much extended to provide a
 complete DNS implementation.
 
 Dnsruby runs a single I/O thread to handle all concurrent
-queries. It is also able to use EventMachine if it is installed.
-It is therefore suitable for high volume DNS applications.
+queries. It is therefore suitable for high volume DNS applications.
 
 The following is a (non-exhaustive) list of features :
 
@@ -47,7 +46,8 @@ Demo code
 =========
 
 The demo folder contains some example programs using Dnsruby.
-These examples include 
+These examples include a basic dig tool (rubydig) and a tool to
+concurrently resolve many names, amongst others.
 
 Online tests
 ============

data/lib/Dnsruby/Config.rb

@@ -115,7 +115,7 @@ module Dnsruby
         send("ndots=",nd)
         send("domain=",dom)        
       }
-      TheLog.info(to_s)
+      Dnsruby.log.info{to_s}
     end
     
     # Set the default domain
@@ -195,7 +195,7 @@ module Dnsruby
       #      @nameserver = ['0.0.0.0'] if (@nameserver.class != Array || @nameserver.empty?)
       # Now go through and ensure that all ns point to IP addresses, not domain names
       @nameserver=ns
-      TheLog.debug("Nameservers = #{@nameserver.join(", ")}")
+      Dnsruby.log.debug{"Nameservers = #{@nameserver.join(", ")}"}
     end
     
     def Config.resolve_server(ns) #:nodoc: all
@@ -216,7 +216,7 @@ module Dnsruby
             addr = TCPSocket.gethostbyname(ns)[3] # @TODO@ Replace this with Dnsruby call when lookups work
             server = addr
           rescue Exception => e
-            TheLog.error("Can't make sense of nameserver : #{server}, exception : #{e}")
+            Dnsruby.log.error{"Can't make sense of nameserver : #{server}, exception : #{e}"}
             raise ArgumentError.new("Can't make sense of nameserver : #{server}, exception : #{e}")
           end
         end

data/lib/Dnsruby/DNS.rb

@@ -175,6 +175,8 @@ module Dnsruby
       case address
       when Name
         ptr = address
+      when  IPv4, IPv6
+        ptr = address.to_name
       when IPv4::Regex
         ptr = IPv4.create(address).to_name
       when IPv6::Regex
@@ -226,10 +228,10 @@ module Dnsruby
         extract_resources(reply, reply_name, type, klass, &proc)
         return
         #      when RCode::NXDomain
-        #        TheLog.debug("RCode::NXDomain returned - raising error")
+        #        Dnsruby.log.debug("RCode::NXDomain returned - raising error")
         #        raise Config::NXDomain.new(reply_name.to_s)
       else
-        TheLog.error("Unexpected rcode : #{reply.header.rcode.string}")
+        Dnsruby.log.error{"Unexpected rcode : #{reply.header.rcode.string}"}
         raise Config::OtherResolvError.new(reply_name.to_s)
       end      
     end

data/lib/Dnsruby/Resolver.rb

@@ -58,9 +58,9 @@ module Dnsruby
     begin
       require 'Dnsruby/event_machine_interface'
       @@event_machine_available=true
-      TheLog.debug("EventMachine loaded")
+      Dnsruby.log.debug{"EventMachine loaded"}
     rescue LoadError
-      TheLog.error("EventMachine not found")
+      Dnsruby.log.error{"EventMachine not found"}
     end
     DefaultQueryTimeout = 0 
     DefaultPacketTimeout = 10
@@ -161,11 +161,11 @@ module Dnsruby
     #     # ...
     #   end
     def send_message(message)
-      TheLog.debug("Resolver : sending message")
+      Dnsruby.log.debug{"Resolver : sending message"}
       q = Queue.new
       send_async(message, q)
       id, result, error = q.pop
-      TheLog.debug("Resolver : result received")
+      Dnsruby.log.debug{"Resolver : result received"}
       if (error != nil)
         raise error
       else
@@ -328,7 +328,7 @@ module Dnsruby
                 send(key.to_s+"=", args[0][key])
               end
             rescue Exception
-              TheLog.error("Argument #{key} not valid\n")
+              Dnsruby.log.error{"Argument #{key} not valid\n"}
             end
           end
         elsif (args[0].class == String)
@@ -349,7 +349,11 @@ module Dnsruby
     def add_config_nameservers
       # Add the Config nameservers
       @config.nameserver.each do |ns|
-        @single_resolvers.push(SingleResolver.new({:server=>ns}))
+        @single_resolvers.push(SingleResolver.new({:server=>ns, :dnssec=>@dnssec,
+            :use_tcp=>@use_tcp, :packet_timeout=>@packet_timeout,
+          :tsig => @tsig, :ignore_truncation=>@ignore_truncation,
+         :src_address=>@src_address, :src_port=>@src_port, 
+         :recurse=>@recurse, :udp_size=>@udp_size}))
       end
     end
     
@@ -497,9 +501,9 @@ module Dnsruby
       end
       @@use_eventmachine = on
       if (on)
-        TheLog.info("EventMachine will be used for IO")
+        Dnsruby.log.info{"EventMachine will be used for IO"}
       else
-        TheLog.info("EventMachine will not be used for IO")
+        Dnsruby.log.info{"EventMachine will not be used for IO"}
       end
     end
     #Check whether EventMachine will be used by Dnsruby
@@ -518,9 +522,9 @@ module Dnsruby
     def Resolver.start_eventmachine_loop(on=true)
       @@start_eventmachine_loop=on
       if (on)
-        TheLog.info("EventMachine loop will be started by Dnsruby")
+        Dnsruby.log.info{"EventMachine loop will be started by Dnsruby"}
       else
-        TheLog.info("EventMachine loop will not be started by Dnsruby")
+        Dnsruby.log.info{"EventMachine loop will not be started by Dnsruby"}
       end
     end
     #Checks whether Dnsruby will start the EventMachine loop when required.
@@ -545,7 +549,7 @@ module Dnsruby
             timeouts[base+offset]=[res, retry_count]
           else
             if (timeouts.has_key?(base+retry_delay+offset))
-              TheLog.error("Duplicate timeout key!")
+              Dnsruby.log.error{"Duplicate timeout key!"}
               raise RuntimeError.new("Duplicate timeout key!")
             end
             timeouts[base+retry_delay+offset]=[res, retry_count]
@@ -601,13 +605,13 @@ module Dnsruby
         df = nil
         if (timeout == 0) 
           # Send immediately
-          TheLog.debug("Sending first EM query")
+          Dnsruby.log.debug{"Sending first EM query"}
           df = send_new_em_query(single_resolver, msg, client_queue, client_query_id, persistent_data)
           persistent_data.outstanding.push(df)
         else
           # Send later
           persistent_data.timer_procs[timeout]=Proc.new{
-            TheLog.debug("Sending #{timeout} delayed EM query")
+            Dnsruby.log.debug{"Sending #{timeout} delayed EM query"}
             df = send_new_em_query(single_resolver, msg, client_queue, client_query_id, persistent_data)
             persistent_data.outstanding.push(df)
           }
@@ -650,13 +654,13 @@ module Dnsruby
       df = single_resolver.send_async(msg) # client_queue, client_query_id)
       persistent_data.to_send-=1
       df.callback { |answer|
-        TheLog.debug("Response returned")
+        Dnsruby.log.debug{"Response returned"}
         persistent_data.outstanding.delete(df)
         cancel_queries(persistent_data)
         return_to_client(persistent_data.deferrable, client_queue, client_query_id, answer, nil)
       }  
       df.errback { |response, error|
-        TheLog.debug("Error #{error} returned")
+        Dnsruby.log.debug{"Error #{error} returned"}
         persistent_data.outstanding.delete(df)
         if (response!="cancelling")
 
@@ -666,17 +670,17 @@ module Dnsruby
             #       - otherwise, continue
             # Do we have any more packets to send to this resolver?
             if (persistent_data.outstanding.empty? && persistent_data.to_send==0)
-              TheLog.debug("Sending timeout to client")
+              Dnsruby.log.debug{"Sending timeout to client"}
               return_to_client(persistent_data.deferrable, client_queue, client_query_id, response, error)
             end
           elsif (error.kind_of?NXDomain)
             #   - if it was an NXDomain, then return that to the client, and stop all new queries (and clean up)
-            TheLog.debug("NXDomain - returning to client")
+            Dnsruby.log.debug{"NXDomain - returning to client"}
             cancel_queries(persistent_data)
             return_to_client(persistent_data.deferrable, client_queue, client_query_id, response, error)
           elsif (error.kind_of?FormErr)
             #   - if it was a FormErr, then return that to the client, and stop all new queries (and clean up)
-            TheLog.debug("FormErr - returning to client")
+            Dnsruby.log.debug{"FormErr - returning to client"}
             cancel_queries(persistent_data)
             return_to_client(persistent_data.deferrable, client_queue, client_query_id, response, error)
           else
@@ -684,14 +688,14 @@ module Dnsruby
             #   If a Too Many Open Files error, then don't remove, but let retry work.
             if (!(error.to_s=~/Errno::EMFILE/))
               remove_server(single_resolver, persistent_data)
-              TheLog.debug("Removing #{single_resolver.server} from resolver list for this query")
+              Dnsruby.log.debug{"Removing #{single_resolver.server} from resolver list for this query"}
             else
-              TheLog.debug("NOT Removing #{single_resolver.server} due to Errno::EMFILE")          
+              Dnsruby.log.debug{"NOT Removing #{single_resolver.server} due to Errno::EMFILE"}
             end
             #        - if it was the last server, then return an error to the client (and clean up)
             if (persistent_data.outstanding.empty? && persistent_data.to_send==0)
               #          if (outstanding.empty?)
-              TheLog.debug("Sending error to client")
+              Dnsruby.log.debug{"Sending error to client"}
               return_to_client(persistent_data.deferrable, client_queue, client_query_id, response, error)
             end
           end
@@ -712,7 +716,7 @@ module Dnsruby
     end
     
     def cancel_queries(persistent_data)
-      TheLog.debug("Cancelling EM queries")
+      Dnsruby.log.debug{"Cancelling EM queries"}
       persistent_data.outstanding.each do |df|
         df.set_deferred_status :failed, "cancelling", "cancelling"
       end
@@ -771,13 +775,13 @@ module Dnsruby
       end
       
       if (!client_queue.kind_of?Queue)
-        TheLog.error("Wrong type for client_queue in Resolver#send_async")
+        Dnsruby.log.error{"Wrong type for client_queue in Resolver#send_async"}
         client_queue.push([client_query_id, ArgumentError.new("Wrong type of client_queue passed to Dnsruby::Resolver#send_async - should have been Queue, was #{client_queue.class}")])
         return
       end
       
       if (!msg.kind_of?Message)
-        TheLog.error("Wrong type for msg in Resolver#send_async")
+        Dnsruby.log.error{"Wrong type for msg in Resolver#send_async"}
         client_queue.push([client_query_id, ArgumentError.new("Wrong type of msg passed to Dnsruby::Resolver#send_async - should have been Message, was #{msg.class}")])
         return
       end
@@ -787,7 +791,7 @@ module Dnsruby
       @mutex.synchronize{
         tick_needed = true if @query_list.empty?
         if (@query_list.has_key?client_query_id)
-          TheLog.error("Duplicate query id requested (#{client_query_id}")
+          Dnsruby.log.error{"Duplicate query id requested (#{client_query_id}"}
           client_queue.push([client_query_id, ArgumentError.new("Client query ID already in use")])
           return
         end
@@ -870,7 +874,7 @@ module Dnsruby
               # Send the next query
               res, retry_count = timeouts[timeout]
               id = [res, msg, client_query_id, retry_count]
-              TheLog.debug("Sending msg to #{res.server}")
+              Dnsruby.log.debug{"Sending msg to #{res.server}"}
               # We should keep a list of the queries which are outstanding
               outstanding.push(id)
               timeouts_done.push(timeout)
@@ -903,24 +907,24 @@ module Dnsruby
       # @TODO@ Currently, tick and handle_queue_event called from select_thread - could have thread chuck events in to tick_queue. But then, clients would have to call in on other thread!
       #
       if (queue.empty?)
-        TheLog.fatal("Queue empty in handle_queue_event!")
+        Dnsruby.log.fatal{"Queue empty in handle_queue_event!"}
         raise RuntimeError.new("Severe internal error - Queue empty in handle_queue_event")
       end
       event_id, response, error = queue.pop
       # We should remove this packet from the list of outstanding packets for this query
       resolver, msg, client_query_id, retry_count = id
       if (id != event_id)
-        TheLog.error("Serious internal error!! #{id} expected, #{event_id} received")
+        Dnsruby.log.error{"Serious internal error!! #{id} expected, #{event_id} received"}
         raise RuntimeError.new("Serious internal error!! #{id} expected, #{event_id} received")
       end
       @mutex.synchronize{
         if (@query_list[client_query_id]==nil)
-          TheLog.debug("Ignoring response for dead query")
+          Dnsruby.log.debug{"Ignoring response for dead query"}
           return
         end
         msg, client_queue, select_queue, outstanding = @query_list[client_query_id]
         if (!outstanding.include?id)
-          TheLog.error("Query id not on outstanding list! #{outstanding.length} items. #{id} not on #{outstanding}")
+          Dnsruby.log.error{"Query id not on outstanding list! #{outstanding.length} items. #{id} not on #{outstanding}"}
           raise RuntimeError.new("Query id not on outstanding!")
         end
         outstanding.delete(id)
@@ -931,14 +935,14 @@ module Dnsruby
       else # if (event.kind_of?(Message))
         handle_response(queue, event_id, response)
         #      else
-        #        TheLog.error("Random object #{event.class} returned through queue to Resolver")
+        #        Dnsruby.log.error("Random object #{event.class} returned through queue to Resolver")
       end
     end
     
     def handle_error_response(select_queue, query_id, error, response) #:nodoc: all
       #Handle an error
       @mutex.synchronize{
-        TheLog.debug("handling error #{error.class}, #{error}")
+        Dnsruby.log.debug{"handling error #{error.class}, #{error}"}
         # Check what sort of error it was :
         resolver, msg, client_query_id, retry_count = query_id
         msg, client_queue, select_queue, outstanding = @query_list[client_query_id]
@@ -949,7 +953,7 @@ module Dnsruby
           # Do we have any more packets to send to this resolver?
           timeouts = @timeouts[client_query_id]
           if (outstanding.empty? && timeouts[1].values.empty?)
-            TheLog.debug("Sending timeout to client")
+            Dnsruby.log.debug{"Sending timeout to client"}
             send_result_and_close(client_queue, client_query_id, select_queue, response, error)
           end
         elsif (error.kind_of?NXDomain)
@@ -960,7 +964,7 @@ module Dnsruby
           #   If a Too Many Open Files error, then don't remove, but let retry work.
           timeouts = @timeouts[client_query_id]
           if (!(error.to_s=~/Errno::EMFILE/))
-            TheLog.debug("Removing #{resolver.server} from resolver list for this query")
+            Dnsruby.log.debug{"Removing #{resolver.server} from resolver list for this query"}
             timeouts[1].each do |key, value|
               res = value[0]
               if (res == resolver)
@@ -968,12 +972,12 @@ module Dnsruby
               end
             end
           else
-            TheLog.debug("NOT Removing #{resolver.server} due to Errno::EMFILE")          
+            Dnsruby.log.debug{"NOT Removing #{resolver.server} due to Errno::EMFILE"}
           end
           #        - if it was the last server, then return an error to the client (and clean up)
           if (outstanding.empty? && timeouts[1].values.empty?)
             #          if (outstanding.empty?)
-            TheLog.debug("Sending error to client")
+            Dnsruby.log.debug{"Sending error to client"}
             send_result_and_close(client_queue, client_query_id, select_queue, response, error)
           end
         end
@@ -984,12 +988,12 @@ module Dnsruby
     
     def handle_response(select_queue, query_id, response) #:nodoc: all
       # Handle a good response
-      TheLog.debug("Handling good response")
+      Dnsruby.log.debug{"Handling good response"}
       resolver, msg, client_query_id, retry_count = query_id
       @mutex.synchronize{
         query, client_queue, s_queue, outstanding = @query_list[client_query_id]
         if (s_queue != select_queue)
-          TheLog.error("Serious internal error : expected select queue #{s_queue}, got #{select_queue}")
+          Dnsruby.log.error{"Serious internal error : expected select queue #{s_queue}, got #{select_queue}"}
           raise RuntimeError.new("Serious internal error : expected select queue #{s_queue}, got #{select_queue}")
         end
         send_result_and_close(client_queue, client_query_id, select_queue, response, nil)

data/lib/Dnsruby/SingleResolver.rb

@@ -129,7 +129,7 @@ module Dnsruby
             tsig = RR.new_from_hash({:type => Types.TSIG, :klass => Classes.ANY, :name => args[0][0], :key => args[0][1]})
           end
         else
-          TheLog.info("TSIG signing switched off")
+          Dnsruby.log.info{"TSIG signing switched off"}
           return nil
         end
       elsif (args.length ==2)
@@ -137,7 +137,7 @@ module Dnsruby
       else
         raise ArgumentError.new("Wrong number of arguments to tsig=")
       end
-      TheLog.info("TSIG signing now using #{tsig.name}, key=#{tsig.key}")
+      Dnsruby.log.info{"TSIG signing now using #{tsig.name}, key=#{tsig.key}"}
       return tsig
     end
     
@@ -146,7 +146,7 @@ module Dnsruby
     end
     
     def server=(server)
-      TheLog.debug("SingleResolver setting server to #{server}")
+      Dnsruby.log.debug{"SingleResolver setting server to #{server}"}
       @server=Config.resolve_server(server)
     end
     
@@ -177,7 +177,9 @@ module Dnsruby
       @recurse = true
       @persistent_udp = false
       @persistent_tcp = false
-      self.dnssec = true
+      @dnssec = true
+      
+      seen_dnssec = false
       
       if (arg==nil)
         # Get default config
@@ -189,12 +191,18 @@ module Dnsruby
         arg.keys.each do |attr|
           begin
             send(attr.to_s+"=", arg[attr])
+            if (attr.to_s == "dnssec")
+                seen_dnssec = true
+            end
           rescue Exception
-            TheLog.error("Argument #{attr} not valid\n")
+            Dnsruby.log.error{"Argument #{attr} not valid\n"}
           end
-          #        end
+        #        end
         end
       end
+      if (!seen_dnssec) 
+        @dnssec = true
+      end
       #Check server is IP
       @server=Config.resolve_server(@server)
       
@@ -224,11 +232,11 @@ module Dnsruby
     def send_message(msg, use_tcp=@use_tcp)
       q = Queue.new
       send_async(msg, q, Time.now + rand(1000000), use_tcp)
-      id, msg, error = q.pop
+      id, reply, error = q.pop
       if (error != nil)
         raise error
       else
-        return msg
+        return reply
       end
     end
     
@@ -287,7 +295,7 @@ module Dnsruby
       end
       query_packet = make_query_packet(msg, use_tcp)
       if (udp_packet_size < query_packet.length)
-        TheLog.debug("Query packet length exceeds max UDP packet size - using TCP")
+        Dnsruby.log.debug{"Query packet length exceeds max UDP packet size - using TCP"}
         use_tcp = true
       end
       if (args.length > 1)
@@ -309,7 +317,7 @@ module Dnsruby
         return send_eventmachine(query_packet, msg, client_query_id, client_queue, use_tcp)
       else
         if (!client_query_id)
-          client_query_id = Time.now + rand(10000)
+          client_query_id = Time.now + rand(10000) # is this safe?!
         end
         send_dnsruby(query_packet, msg, client_query_id, client_queue, use_tcp)
         return client_query_id
@@ -327,7 +335,7 @@ module Dnsruby
         ret = true
         if (response.header.tc && !use_tcp && !@ignore_truncation)
           # Try to resend over tcp
-          TheLog.debug("Truncated - resending over TCP")
+          Dnsruby.log.debug{"Truncated - resending over TCP"}
           send_eventmachine(msg_bytes, msg, client_query_id, client_queue, true, client_deferrable, packet_timeout - (Time.now-start_time))
         else
           if (!check_tsig(msg, response, response_bytes))
@@ -370,17 +378,17 @@ module Dnsruby
           socket.close
         end
         err=IOError.new("dnsruby can't connect to #{@server}:#{@port} from #{@src_addr}:#{src_port}, use_tcp=#{use_tcp}, exception = #{e.class}, #{e}")
-        TheLog.error("#{err}")
+        Dnsruby.log.error{"#{err}"}
         st.push_exception_to_select(client_query_id, client_queue, err, nil) # @TODO Do we still need this? Can we not just send it from here?
         return
       end
       if (socket==nil)
         err=IOError.new("dnsruby can't connect to #{@server}:#{@port} from #{@src_addr}:#{src_port}, use_tcp=#{use_tcp}")
-        TheLog.error("#{err}")
+        Dnsruby.log.error{"#{err}"}
         st.push_exception_to_select(client_query_id, client_queue, err, nil) # @TODO Do we still need this? Can we not just send it from here?
         return
       end
-      TheLog.debug("Sending packet to #{@server}:#{@port} from #{@src_addr}:#{src_port}, use_tcp=#{use_tcp}")
+      Dnsruby.log.debug{"Sending packet to #{@server}:#{@port} from #{@src_addr}:#{src_port}, use_tcp=#{use_tcp}"}
       begin
         if (use_tcp)
           lenmsg = [query_bytes.length].pack('n')
@@ -390,7 +398,7 @@ module Dnsruby
       rescue Exception => e
         socket.close
         err=IOError.new("Send failed to #{@server}:#{@port} from #{@src_addr}:#{src_port}, use_tcp=#{use_tcp}, exception : #{e}")
-        TheLog.error("#{err}")
+        Dnsruby.log.error{"#{err}"}
         st.push_exception_to_select(client_query_id, client_queue, err, nil)
         return
       end
@@ -421,7 +429,7 @@ module Dnsruby
       end
       if (response.header.tc && !tcp)
         # Try to resend over tcp
-        TheLog.debug("Truncated - resending over TCP")
+        Dnsruby.log.debug{"Truncated - resending over TCP"}
         send_async(query, client_queue, client_query_id, true)
         return false
       end
@@ -433,17 +441,17 @@ module Dnsruby
         if (response.tsig)
           if !query.tsig.verify(query, response, response_bytes)
             # Discard packet and wait for correctly signed response
-            TheLog.error("TSIG authentication failed!")
+            Dnsruby.log.error{"TSIG authentication failed!"}
             return false
           end
         else
           # Treated as having format error and discarded (RFC2845, 4.6)
-          TheLog.error("Expecting TSIG signed response, but got unsigned response - discarding")
+          Dnsruby.log.error{"Expecting TSIG signed response, but got unsigned response - discarding"}
           return false
         end
       elsif (response.tsig)
         # Error - signed response to unsigned query
-        TheLog.error("Signed response to unsigned query")
+        Dnsruby.log.error{"Signed response to unsigned query"}
         return false
       end      
       return true
@@ -457,7 +465,7 @@ module Dnsruby
       
       if (@dnssec)
         # RFC 4035
-        TheLog.debug(";; Adding EDNS extention with UDP packetsize #{udp_packet_size} and DNS OK bit set\n")
+        Dnsruby.log.debug{";; Adding EDNS extention with UDP packetsize #{udp_packet_size} and DNS OK bit set\n"}
         optrr = RR::OPT.new(udp_packet_size)   # Decimal UDPpayload
         optrr.dnssec_ok=true
               
@@ -469,7 +477,7 @@ module Dnsruby
               
       elsif ((udp_packet_size > Resolver::DefaultUDPSize) && !use_tcp)
         #      if ((udp_packet_size > Resolver::DefaultUDPSize) && !use_tcp)
-        TheLog.debug(";; Adding EDNS extention with UDP packetsize  #{udp_packet_size}.\n")
+        Dnsruby.log.debug{";; Adding EDNS extention with UDP packetsize  #{udp_packet_size}.\n"}
         # RFC 3225
         optrr = RR::OPT.new(udp_packet_size)
         

data/lib/Dnsruby/TheLog.rb

@@ -17,7 +17,7 @@ require 'logger'
 require 'singleton'
 require 'thread'
 module Dnsruby
-  #This singleton class holds a reference to the Logger object used by the whole of the Dnsruby project.
+  #This class exists for backwards compatibility.
   #
   #It's Logger (which defaults to STDOUT, level FATAL) can be configured, or a new Logger can be supplied.
   #
@@ -25,36 +25,20 @@ module Dnsruby
   # Dnsruby::TheLog.debug("Debug message")
   # 
   class TheLog
-    include Singleton
-    def initialize() #:nodoc: all
-      @@mutex=Mutex.new
-      @@logger = Logger.new(STDOUT)
-      @@logger.level = Logger::FATAL
-    end
     # Set a new Logger for use by Dnsruby
     def set_logger(logger)
-      @@mutex.synchronize{
-        @@logger = logger
-      }
+      Dnsruby.log = logger
     end
     # Change the Logger level.
     def level=(level)
-      @@mutex.synchronize{
-        @@logger.level = level
-      }
+      Dnsruby.log.level = level
     end
     def level
-      @@mutex.synchronize{
-        return @@logger.level
-      }
+      return Dnsruby.log.level
     end
     
     def self.method_missing(symbol, *args) #:nodoc: all
-      @@mutex.synchronize{
-        now = Time.now
-        @@logger.send(symbol, *args)
-      }
+        Dnsruby.log.send(symbol, *args)
     end
-    log = TheLog.instance
   end
 end

data/lib/Dnsruby/dnssec.rb

@@ -313,7 +313,7 @@ module Dnsruby
       #3.1.8.1.  Signature Calculation
       
       if (keyrec.sep_key? && !keyrec.zone_key?)
-        TheLog.error("DNSKEY with with SEP flag set and Zone Key flag not set was used to verify RRSIG over RRSET - this is not allowed by RFC4034 section 2.1.1")
+        Dnsruby.log.error("DNSKEY with with SEP flag set and Zone Key flag not set was used to verify RRSIG over RRSET - this is not allowed by RFC4034 section 2.1.1")
         return false
       end