diff --git a/lib/puppet/util/logging.rb b/lib/puppet/util/logging.rb
index bc52b17f0..b6845b8fa 100644
--- a/lib/puppet/util/logging.rb
+++ b/lib/puppet/util/logging.rb
@@ -1,40 +1,51 @@
 # A module to make logging a bit easier.
 require 'puppet/util/log'
 
 module Puppet::Util::Logging
 
   def send_log(level, message)
     Puppet::Util::Log.create({:level => level, :source => log_source, :message => message}.merge(log_metadata))
   end
 
   # Create a method for each log level.
   Puppet::Util::Log.eachlevel do |level|
     define_method(level) do |args|
       args = args.join(" ") if args.is_a?(Array)
       send_log(level, args)
     end
   end
 
+  def deprication_warning(message)
+    $deprication_warnings ||= Hash.new(0)
+    if $deprication_warnings.length < 100 and ($deprication_warnings[message] += 1) == 1
+      warn message
+    end
+  end
+
+  def clear_deprication_warnings
+    $deprication_warnings.clear if $deprication_warnings
+  end
+
   private
 
   def is_resource?
     defined?(Puppet::Type) && is_a?(Puppet::Type)
   end
 
   def is_resource_parameter?
     defined?(Puppet::Parameter) && is_a?(Puppet::Parameter)
   end
 
   def log_metadata
     [:file, :line, :tags].inject({}) do |result, attr|
       result[attr] = send(attr) if respond_to?(attr)
       result
     end
   end
 
   def log_source
     # We need to guard the existence of the constants, since this module is used by the base Puppet module.
     (is_resource? or is_resource_parameter?) and respond_to?(:path) and return path.to_s
     to_s
   end
 end
diff --git a/spec/unit/util/logging_spec.rb b/spec/unit/util/logging_spec.rb
index edc88f115..1585c3e64 100755
--- a/spec/unit/util/logging_spec.rb
+++ b/spec/unit/util/logging_spec.rb
@@ -1,95 +1,120 @@
 #!/usr/bin/env ruby
 
 require 'spec_helper'
 
 require 'puppet/util/logging'
 
 class LoggingTester
   include Puppet::Util::Logging
 end
 
 describe Puppet::Util::Logging do
   before do
     @logger = LoggingTester.new
   end
 
   Puppet::Util::Log.eachlevel do |level|
     it "should have a method for sending '#{level}' logs" do
       @logger.should respond_to(level)
     end
   end
 
   it "should have a method for sending a log with a specified log level" do
     @logger.expects(:to_s).returns "I'm a string!"
     Puppet::Util::Log.expects(:create).with { |args| args[:source] == "I'm a string!" and args[:level] == "loglevel" and args[:message] == "mymessage" }
 
     @logger.send_log "loglevel", "mymessage"
   end
 
   describe "when sending a log" do
     it "should use the Log's 'create' entrance method" do
       Puppet::Util::Log.expects(:create)
 
       @logger.notice "foo"
     end
 
     it "should send itself converted to a string as the log source" do
       @logger.expects(:to_s).returns "I'm a string!"
       Puppet::Util::Log.expects(:create).with { |args| args[:source] == "I'm a string!" }
 
       @logger.notice "foo"
     end
 
     it "should queue logs sent without a specified destination" do
       Puppet::Util::Log.close_all
       Puppet::Util::Log.expects(:queuemessage)
 
       @logger.notice "foo"
     end
 
     it "should use the path of any provided resource type" do
       resource = Puppet::Type.type(:mount).new :name => "foo"
 
       resource.expects(:path).returns "/path/to/mount".to_sym
 
       Puppet::Util::Log.expects(:create).with { |args| args[:source] == "/path/to/mount" }
 
       resource.notice "foo"
     end
 
     it "should use the path of any provided resource parameter" do
       resource = Puppet::Type.type(:mount).new :name => "foo"
 
       param = resource.parameter(:name)
 
       param.expects(:path).returns "/path/to/param".to_sym
 
       Puppet::Util::Log.expects(:create).with { |args| args[:source] == "/path/to/param" }
 
       param.notice "foo"
     end
 
     it "should send the provided argument as the log message" do
       Puppet::Util::Log.expects(:create).with { |args| args[:message] == "foo" }
 
       @logger.notice "foo"
     end
 
     it "should join any provided arguments into a single string for the message" do
       Puppet::Util::Log.expects(:create).with { |args| args[:message] == "foo bar baz" }
 
       @logger.notice ["foo", "bar", "baz"]
     end
 
     [:file, :line, :tags].each do |attr|
       it "should include #{attr} if available" do
         @logger.singleton_class.send(:attr_accessor, attr)
 
         @logger.send(attr.to_s + "=", "myval")
 
         Puppet::Util::Log.expects(:create).with { |args| args[attr] == "myval" }
         @logger.notice "foo"
       end
     end
   end
+
+  describe "when sending a deprication warning" do
+    before do
+      @logger.clear_deprication_warnings
+    end
+
+    it "should the message with warn" do
+      @logger.expects(:warn).with('foo')
+      @logger.deprication_warning 'foo'
+    end
+
+    it "should only log each unique message once" do
+      @logger.expects(:warn).with('foo').once
+      5.times { @logger.deprication_warning 'foo' }
+    end
+
+    it "should only log the first 100 messages" do
+      (1..100).each { |i|
+          @logger.expects(:warn).with(i).once
+          @logger.deprication_warning i
+      }
+      @logger.expects(:warn).with(101).never
+      @logger.deprication_warning 101
+    end
+  end
 end