aquarium 0.1.8 → 0.2.0

data/CHANGES

@@ -1,7 +1,64 @@
+== Version 0.2.0
+
+V0.2.0 changes the parameter list used for advice blocks and adds numerous enhancements, robustness
+improvements and more complete "spec'ing".
+
+Bug fixes:
+none
+
+Enhancements:
+13402	Support a subclass syntax like AspectJ's "Type+"
+13984	More flexible argument list to the advise block
+14053	Remove JoinPoint#type, JoinPoint#type=, JoinPoint#object, and JoinPoint#object=
+14061	Add a control flow mechanism to skipping (sic) intermediate advice
+15164	Deprecate ObjectFinder
+15413	Remove ObjectFinder
+15710	Eliminate redundant public methods in various "finders"
+
+#13402 adds new invocation options to specify types and their descendents (subclasses or modules
+that include the specified module(s)) and ancestors. The latter should be used cautiously as it
+will include things like Kernel, Object, and Class!  I used new command options rather than the
+AspectJ "+" suffix (and the proposed, but never implemented "-" suffix for ancestors), because
+the "+" would be confusing with regular expressions and not in the spirit of trying to make
+the pointcut language "easy to read". So, the following are now available:
+  :type_and_ancestors
+  :types_and_ancestors
+  :type_and_descendents
+  :types_and_descendents
+And the corresponding:
+  :exclude_type_and_ancestors
+  :exclude_types_and_ancestors
+  :exclude_type_and_descendents
+  :exclude_types_and_descendents
+If you want both the ancestors and descendents, just use both options with the same value.
+
+#13984 adds the object as the second argument to the advice block parameter list. This change
+reflects the fact that the object is often needed, but calling jp.context.advised_object is a
+bit tedious. THIS CHANGE BREAKS BACKWARDS COMPATIBILITY!! An exception is raised if advice has
+the signature |jp, *args|.
+
+#14061 adds a new method, JoinPoint#invoke_original_join_point, which will invoke the original
+method without intermediate advice. If called within around advice, you can write advice that 
+vetoes all subsequent advice, yet invokes the original method. Use this technique cautiously, 
+however, since you may not always know what other advices are involved and what side effects 
+this control-flow change might cause.
+
+#15164 and 15413 remove ObjectFinder because it is not used and it requires ObjectSpace, which 
+has high overhead and won't be enabled, by default, in JRuby (it will be optional).
+
+#15710 removes redundant methods that were becoming a maintenance issue, in particular, 
+MethodFinder#find_all_by and TypeFinder#find_by_name. This is a non-backwards-compatible API
+change. 
+
+Finally, note that I have not yet been able to resolve bug #15202, "Intermittent confusion
+between classes and objects when invoking advice." I believe this is a very rare occurrence
+and only likely to ever happen during the "torture-test" of running the RSpec suite. Please post
+a comment to Tracker if you encounter it!
+
 == Version 0.1.8
 
-V0.1.7 did not successfully "register" at rubyforge. This releases fixes that problem and also adds
-several feature enhancements and refactorings. There are no known upgrade issues.
+V0.1.7 did not successfully "register" at rubyforge. This releases fixes that problem and also
+adds several feature enhancements and refactorings. There are no known upgrade issues.
 
 Bug fixes:
 none

data/README

@@ -50,7 +50,7 @@ Many of AspectJ's behaviors that aren't currently supported are planned for futu
 * At this time, the pointcut language supported by Aquarium is not nearly as feature-rich as AspectJ's language. For example, there are no runtime pointcut designators supported, such as "if" conditions and "cflow" (context flow). Most of AspectJ pointcut language features are planned, however.
 * While AspectJ provides "intertype declaration" capabilities (i.e., adding state and behavior to existing classes), Ruby's native metaprogramming support satisfies this need. There may be convenience hooks added in a future release, however.
 * User defined advice precedence is not supported. However, advice precedence is unambiguous; the last aspects created while modules are loaded at runtime have higher precedence than earlier aspects. Ensuring a particular order is not always easy, of course. 
-* Unlike AspectJ, Aquarium can advise individual objects, can remove advice, and it supports named advice that can be defined separately from the aspects that use the advice.
+* Unlike AspectJ, Aquarium can advise individual objects, can remove advice, and it supports named advice that can be defined separately from the aspects that use the advice. Aquarium can also advise ancestor (parent) types, not just derived (descendent) types of specified types.
 
 === Examples
 
@@ -61,20 +61,20 @@ In most cases, you can either declare the appropriate classes or use the optiona
 Here is an example that traces invocations of all public instance methods (included inherited ones) of the classes or modules Foo and Bar.
 
 	require 'aquarium'
-	Aspect.new :around, :types => [Foo, Bar], :methods => :all do |join_point, *args|
-		p "Entering: #{join_point.target_type.name}##{join_point.method_name}"
+	Aspect.new :around, :types => [Foo, Bar], :methods => :all do |join_point, object, *args|
+		p "Entering: #{join_point.target_type.name}##{join_point.method_name} for object #{object}"
 		result = join_point.proceed
-		p "Leaving: #{join_point.target_type.name}##{join_point.method_name}"
+		p "Leaving: #{join_point.target_type.name}##{join_point.method_name} for object #{object}"
 		result  # block needs to return the result of the "proceed"!
 	end
 
 The advice to execute at each join point is the block. The pointcut is the set of all public instance methods in Foo and Bar. (There are additional options available for specifying class methods, protected methods, excluding inherited (ancestor) methods, etc.) Here is the same example using the convenience DSL that adds aspect methods to Object (available only if you require aquarium/aspects/dsl/object_dsl', since other toolkits, like Rails, define similar methods on Object!).
 
 	require 'aquarium/aspects/dsl/object_dsl'
-	around :types => [Foo, Bar], :methods => :all do |join_point, *args|
-		p "Entering: #{join_point.target_type.name}##{join_point.method_name}"
+	around :types => [Foo, Bar], :methods => :all do |join_point, object, *args|
+		p "Entering: #{join_point.target_type.name}##{join_point.method_name} for object #{object}"
 		result = join_point.proceed
-		p "Leaving: #{join_point.target_type.name}##{join_point.method_name}"
+		p "Leaving: #{join_point.target_type.name}##{join_point.method_name} for object #{object}"
 		result  # block needs to return the result of the "proceed"!
 	end
 
@@ -106,7 +106,7 @@ If you use the DSL inside a class and omit the :type(s) and :object(s) options,
 	end
 	...
 	class Foo
-		around :critical_operation do |join_point, *args|
+		around :critical_operation do |join_point, object, *args|
 			p "Entering: Foo#critical_operation"
 			result = join_point.proceed
 			p "Leaving: Foo#critical_operation"
@@ -116,22 +116,22 @@ If you use the DSL inside a class and omit the :type(s) and :object(s) options,
 
 It is important to note that aspect "instances" usually behave like class (static) variables, in terms of the lifetime of their effects. In the example shown, class Foo is permanently modified to do the print statements shown for all "critical methods", unless you save the result of calling "around" to a variable, e.g., critical_operation_logging, and you explicitly call "critical_operation_logging.unadvise" at some future time. Put another way, the effects scope just like changes made when you reopen a class or module.
 
-A common mistake is to create an aspect in an initialize method and assign it to an attribute. This usually means that you are creating long-lived, redundant aspects every time an instance is created. The aspect modifications remain in effect even when the instances themselves are garbage collected!
+A common mistake is to create an aspect in an initialize method and assign it to an attribute. This usually means that you are creating long-lived, redundant aspects every time an instance of your class is created. The aspect modifications remain in effect even when the instances themselves are garbage collected!
  
 Here are some more succinct examples, illustrating the API (using the DSL methods).
 
 You can pass in pointcuts defined elsewhere:
 
 	my_pointcut = Pointcut.new :types => /Foo::Bar::/, :methods => /^do_/
-	around :pointcuts => my_pointcut do |jp, *args| ...         # Pass in a pointcut
-	around :pointcuts => [my_pointcut, ...] do |jp, *args| ...  # Pass in a pointcut array
+	around :pointcuts => my_pointcut do |jp, obj, *args| ...         # Pass in a pointcut
+	around :pointcuts => [my_pointcut, ...] do |jp, obj, *args| ...  # Pass in a pointcut array
 
 As a convenience, since a JoinPoint is like a Pointcut with one element, you can pass a JoinPoint object where Pointcut objects are expected:
 
 my_join_point1 = JoinPoint.new :type => Foo::Bar, :method => do_this
 my_join_point2 = JoinPoint.new :type => Foo::Bar, :method => do_that
-around :pointcuts => my_join_point1 do |jp, *args| ...         
-around :pointcuts => [my_join_point1, my_join_point2, ...] do |jp, *args| ...  
+around :pointcuts => my_join_point1 do |jp, obj, *args| ...         
+around :pointcuts => [my_join_point1, my_join_point2, ...] do |jp, obj, *args| ...  
 
 You can specify a single type, a type name, a type regular expression, or an array of the same. Note that :type and :types are synonymous "sugar".
 
@@ -142,6 +142,13 @@ You can specify a single type, a type name, a type regular expression, or an arr
 	around :types => /A::.*Helper$/, ...
 	around :types => [/A::.*Helper$/, /B::Foo.*/], ...
 	
+You can specify types and their descendents (subclasses or included modules) or ancestors.
+
+	around :type_and_ancestors = A, ...
+	around :types_and_ancestors = A, ...
+	around :type_and_descendents = A, ...
+	around :types_and_descendents = A, ...
+	
 You can specify a single object or an array of objects. Note that :object and :objects are synonymous. 
 
 	a1 = A.new
@@ -204,6 +211,10 @@ of the same types. (This is not likely to happen a lot in real applications, but
 	around ..., :exclude_join_points = [jp, ...]
 	around ..., :exclude_type = t, ...
 	around ..., :exclude_types = [t, ...]
+	around ..., :exclude_type_and_ancestors = t, ...
+	around ..., :exclude_types_and_ancestors = [t, ...]
+	around ..., :exclude_type_and_descendents = t, ...
+	around ..., :exclude_types_and_descendents = [t, ...]
 	around ..., :exclude_object = o, ...
 	around ..., :exclude_objects = [o, ...]
 	around ..., :exclude_method = m, ...
@@ -243,18 +254,24 @@ You can advice methods both before after. This is different from around advice,
 	before_and_after_raising_within :types =>, ...	# synonym
 	before_and_after_raising_within_or_returning_from :types =>, ...	# synonym
 
-You can pass a block as the advice. Notice that all advice blocks and Procs (see below) are required to accept two arguments, the JoinPoint, which will contain useful context information, and "*args", which will contain the parameters used when invoking the join point (method). A block or advice argument is required, but it can be empty.
+If you pass a block to Aspect.new, it will be the advice. When invoked, the advice will be passed the following three arguments, 
+	1) the JoinPoint, which will contain a JoinPoint::Context object with useful context information, 
+	2) the object being sent the current message, and 
+	3) the parameters passed with the original message. 
+Recall that Proc don't check the number of arguments (while lambdas do), so if you don't care about any trailing parameters, you can leave them out of the parameter list. Recall that the other difference between the two is that a return statement in a Proc returns from the method that contains it. As rule, do NOT use return statements in advices!
 
-	around :type => [...], :methods => :all do |join_point, *args|
+	around :type => [...], :methods => :all do |join_point, object, *args|
 	  advice_to_execute_before_the_jp
 	  result = join_point.proceed	# Invoke the join point, passing *args implicitly (you can override...)
 	  advice_to_execute_after_the_jp
 	  result     # return the result of the "proceed", unless you override the value.
 	end
-	around(:type => [...], :methods => :all) {|join_point, *args| ...}  # (...) necessary for precedence...
+	around(:type => [...], :methods => :all) {|join_point, object, *args| ...}  # (...) necessary for precedence...
 
 In the example, we show that you must be careful to return the correct value, usually the value returned by "proceed" or a value created by the block itself.
 
+Note, prior to V0.2.0, the advice argument list was |join_point, *args|. Aquarium will look for such obsolete signatures (by looking at the arity of the proc) and raise an exception, if found. This check will be removed in a future release.
+ 
 Rather than passing a block as the advice, you can pass a previously-created Proc:
 	
 	around :type => [...], :methods => :all, :advice => advice 

data/RELEASE-PLAN

@@ -15,11 +15,34 @@ This change will obvious break existing aspects.
 
 === Versions 0.3+.0
 
-More refinements to the API and functionality. The main thrust will be expanding the pointcut 
-language to include conditionals and stack context constructs, as well as more intuitive ways
-of expressing sets of types, such as types nested arbitrarily deep in module "namespaces",
-etc.
+More refinements and simpliciations to the API and functionality, including much-needed redundancy
+reduction. I haven't used mocks much in the specs, but they are clearly needed now to improve 
+performance of RSpec runs. 
 
+The main thrust of new feature work will be expanding the pointcut language to include 
+conditionals and stack context constructs, as well as more intuitive ways of expressing sets of 
+types, such as types nested arbitrarily deep in module "namespaces" (e.g., #13403), etc. 
+
+I'm also thinking about an alternative syntax for the DSL. Instead of just this:
+
+	Aspect.new :around :pointcuts => [pc1, pc2, ...] do |jp, object, *args| 
+		# advise
+	end
+
+How about something like the following?
+
+	around do
+ 		pointcuts pc1 or pc2
+ 		advise_with do |jp, object, *args| 
+			# advise
+		end
+	end
+
+I'm not sure it adds much (at this stage of thinking about it...) except that it could make 
+composition of complete pointcuts easier.
+	
 === Version 1.0.0
 
-Reasonable stable and full-featured API and DSL.
+Reasonable stable and full-featured API and DSL. Also, to justify Aquarium's existence ;), I want
+to produce some non-trivial examples of refactoring known APIs and demonstrating improved clarity,
+productivity, modularity, etc., etc.

data/UPGRADE

@@ -1,3 +1,14 @@
+== Upgrading to Aquarium-0.2.0
+
+This release changes the expected advice parameter list from |join_point, *method_args| to
+|join_point, object, *method_args|, where "object" is the current object receiving the message
+corresponding to the advised join point.  Therefore, when you upgrade, you will need to modify your
+advices to take this extra argument, even if you don't use it. Since an advice of |jp, *args| would
+silently "absorb" the object into the beginning of "*args", thereby potentially causing confusion,
+Aquarium will raise an exception if the advice block or proc has this obsolete signature. 
+
+Note that "JoinPoint#Context.advised_object" is still supported, even if it is now less useful.
+
 == Upgrading to Aquarium-0.1.8
 
 V0.1.7 did not successfully "register" at rubyforge. This releases fixes that problem and also adds

data/examples/aspect_design_example.rb

@@ -34,9 +34,9 @@ include Aquarium::Aspects
 
 # Observe state changes in the class, using the class-defined pointcut.
 
-observer = Aspect.new :after, :pointcut => Aquarium::ClassWithStateAndBehavior::STATE_CHANGE do |jp, *args|
+observer = Aspect.new :after, :pointcut => Aquarium::ClassWithStateAndBehavior::STATE_CHANGE do |jp, obj, *args|
   p "State has changed. "
-  state = jp.context.advised_object.state
+  state = obj.state
   p "  New state is #{state.nil? ? 'nil' : state.inspect}"
   p "  Equivalent to *args: #{args.inspect}"
 end  

data/examples/aspect_design_example_spec.rb

@@ -33,8 +33,8 @@ include Aquarium::Aspects
 describe "An example of an aspect using a class-defined pointcut." do
   it "should observe state changes in the class." do
     @new_state = nil
-    observer = Aspect.new :after, :pointcut => Aquarium::ClassWithStateAndBehavior::STATE_CHANGE do |jp, *args|
-      @new_state = jp.context.advised_object.state
+    observer = Aspect.new :after, :pointcut => Aquarium::ClassWithStateAndBehavior::STATE_CHANGE do |jp, obj, *args|
+      @new_state = obj.state
       @new_state.should be_eql(*args)
     end
     object = Aquarium::ClassWithStateAndBehavior.new(:a1, :a2, :a3)

data/examples/design_by_contract_example.rb

@@ -15,7 +15,7 @@ module Aquarium
       p "inside :action"
     end
   
-    precondition :method => :action, :message => "Must pass more than one argument." do |jp, *args|
+    precondition :method => :action, :message => "Must pass more than one argument." do |jp, obj, *args|
       args.size > 0
     end
   end
@@ -37,7 +37,7 @@ module Aquarium
     end
   
     postcondition :method => :action, 
-      :message => "Must pass more than one argument and first argument must be non-empty." do |jp, *args|
+      :message => "Must pass more than one argument and first argument must be non-empty." do |jp, obj, *args|
       args.size > 0 && ! args[0].empty?
     end
   end
@@ -71,8 +71,8 @@ module Aquarium
       @invar = 1
     end
   
-    invariant :methods => /action$/, :message => "Must not change the @invar value." do |jp, *args|
-      jp.context.advised_object.invar == 0
+    invariant :methods => /action$/, :message => "Must not change the @invar value." do |jp, obj, *args|
+      obj.invar == 0
     end
   end
 end

data/examples/design_by_contract_example_spec.rb

@@ -16,7 +16,7 @@ module Aquarium
     end
     attr_reader :state
 
-    precondition :method => :action, :message => "Must pass more than one argument." do |jp, *args|
+    precondition :method => :action, :message => "Must pass more than one argument." do |jp, obj, *args|
       args.size > 0
     end
   end
@@ -42,7 +42,7 @@ module Aquarium
     attr_reader :state
 
     postcondition :method => :action, 
-      :message => "Must pass more than one argument and first argument must be non-empty." do |jp, *args|
+      :message => "Must pass more than one argument and first argument must be non-empty." do |jp, obj, *args|
       args.size > 0 && ! args[0].empty?
     end
   end
@@ -73,8 +73,8 @@ module Aquarium
       @invar = 1
     end
 
-    invariant :methods => /action$/, :message => "Must not change the @invar value." do |jp, *args|
-      jp.context.advised_object.invar == 0
+    invariant :methods => /action$/, :message => "Must not change the @invar value." do |jp, obj, *args|
+      obj.invar == 0
     end
   end
 end

data/examples/method_missing_example.rb

@@ -19,6 +19,9 @@ module Aquarium
     def method_missing sym, *args
       p "Echoing: #{sym.to_s}: #{args.join(" ")}"
     end
+    def respond_to? sym, include_private = false
+      true
+    end
   end
 end
 
@@ -28,7 +31,7 @@ echo1.say "hello", "world!"
 echo1.log "something", "interesting..."
 echo1.shout "theater", "in", "a", "crowded", "firehouse!"
 
-Aquarium::Aspects::Aspect.new :around, :type => Aquarium::Echo, :method => :method_missing do |join_point, sym, *args|
+Aquarium::Aspects::Aspect.new :around, :type => Aquarium::Echo, :method => :method_missing do |join_point, obj, sym, *args|
   if sym == :log 
     p "--- Sending to log: #{args.join(" ")}" 
   else

data/examples/method_missing_example_spec.rb

@@ -20,6 +20,9 @@ module Aquarium
       @log << "Echoing: #{sym.to_s}: #{args.join(" ")}"
     end
     def logged_messages; @log; end
+    def respond_to? sym, include_private = false
+      true
+    end
   end
 end
 
@@ -39,7 +42,7 @@ end
 describe "An example of a class' method_missing with around advice" do
   it "should only handle invocations not processed by the around advice." do
     @intercepted_message = nil
-    aspect = Aquarium::Aspects::Aspect.new :around, :type => Aquarium::Echo, :method => :method_missing do |join_point, sym, *args|
+    aspect = Aquarium::Aspects::Aspect.new :around, :type => Aquarium::Echo, :method => :method_missing do |join_point, obj, sym, *args|
       if sym == :log 
         @intercepted_message = "log: #{args.join(" ")}" 
       else

data/examples/method_tracing_example.rb

@@ -39,7 +39,7 @@ bar1.do_something_else :b3, :b4
 include Aquarium::Aspects
 
 Aspect.new :around, :types => [Aquarium::Foo, Aquarium::Bar], :methods => :all, 
-    :method_options => :exclude_ancestor_methods do |execution_point, *args|
+    :method_options => :exclude_ancestor_methods do |execution_point, obj, *args|
   begin
     p "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
     execution_point.proceed
@@ -58,7 +58,7 @@ bar1.do_something_else :b7, :b8
 # The "begin/ensure/end" idiom shown causes the advice to return the correct value; the result
 # of the "proceed", rather than the value returned by "p"!
 Aspect.new :around, :types => [Aquarium::Foo, Aquarium::Bar], :methods => :initialize, 
-    :method_options => :private do |execution_point, *args|
+    :method_options => :private do |execution_point, obj, *args|
   begin
     p "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
     execution_point.proceed

data/examples/method_tracing_example_spec.rb

@@ -56,13 +56,13 @@ describe "An example with advice on the public instance methods (excluding ances
   it "should trace all calls to the public methods defined by Foo" do
     # The "begin/ensure/end" idiom shown causes the advice to return the correct value; the result
     # of the "proceed", rather than the value returned by "p"!
-    aspect = Aquarium::Aspects::Aspect.new :around, :type => Aquarium::Foo, :methods => :all, :method_options => :exclude_ancestor_methods do |execution_point, *args|
+    aspect = Aquarium::Aspects::Aspect.new :around, 
+      :type => Aquarium::Foo, :methods => :all, :method_options => :exclude_ancestor_methods do |execution_point, obj, *args|
       begin
-        o = execution_point.context.advised_object
-        o.log "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+        obj.log "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
         execution_point.proceed
       ensure
-        o.log "Leaving: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+        obj.log "Leaving: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
       end
     end
     
@@ -79,13 +79,13 @@ end
 
 describe "An example with advice on the public instance methods (excluding ancestor methods) of Bar" do
   it "should not trace any calls to the public methods defined by the included BarModule" do
-    aspect = Aquarium::Aspects::Aspect.new :around, :type => Aquarium::Bar, :methods => :all, :method_options => :exclude_ancestor_methods do |execution_point, *args|
+    aspect = Aquarium::Aspects::Aspect.new :around, 
+      :type => Aquarium::Bar, :methods => :all, :method_options => :exclude_ancestor_methods do |execution_point, obj, *args|
       begin
-        o = execution_point.context.advised_object
-        o.log "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+        obj.log "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
         execution_point.proceed
       ensure
-        o.log "Leaving: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+        obj.log "Leaving: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
       end
     end
     
@@ -98,13 +98,13 @@ end
 
 describe "An example with advice on the public instance methods (including ancestor methods) of Bar" do
   it "should trace all calls to the public methods defined by the included BarModule" do
-    aspect = Aquarium::Aspects::Aspect.new :around, :type => Aquarium::Bar, :methods => /^do_/ do |execution_point, *args|
+    aspect = Aquarium::Aspects::Aspect.new :around, 
+      :type => Aquarium::Bar, :methods => /^do_/ do |execution_point, obj, *args|
       begin
-        o = execution_point.context.advised_object
-        o.log "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+        obj.log "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
         execution_point.proceed
       ensure
-        o.log "Leaving: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+        obj.log "Leaving: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
       end
     end
     
@@ -123,13 +123,13 @@ end
 describe "An example with advice on the private initialize method of Foo and Bar" do
   it "should trace all calls to initialize" do
     before_methods = Aquarium::Foo.private_instance_methods.sort #- Object.private_methods.sort
-    aspect = Aquarium::Aspects::Aspect.new :around, :types => [Aquarium::Foo, Aquarium::Bar], :methods => :initialize, :method_options => :private do |execution_point, *args|
+    aspect = Aquarium::Aspects::Aspect.new :around, 
+      :types => [Aquarium::Foo, Aquarium::Bar], :methods => :initialize, :method_options => :private do |execution_point, obj, *args|
       begin
-        o = execution_point.context.advised_object
-        o.log "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+        obj.log "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
         execution_point.proceed
       ensure
-        o.log "Leaving: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+        obj.log "Leaving: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
       end
     end