rails_customerbeats 0.0.4

data/lib/rails_customerbeats/engine.rb

@@ -0,0 +1,43 @@
+module RailsCustomerbeats
+  class Engine < Rails::Engine
+
+    # Initialize configure parameters
+    config.rails_customerbeats = ActiveSupport::OrderedOptions.new
+
+    config.rails_customerbeats.ignore_lambdas  = {}
+    config.rails_customerbeats.ignore_patterns = [ "start_processing.action_controller", 
+                                              "sql.active_record", 
+                                              "!render_template.action_view",
+                                              "render_partial.action_view",
+                                              "render_template.action_view" ]
+    
+    config.rails_customerbeats.ignore_lambdas['rack.request'] = lambda { |name, payload|
+                                    payload[:path] =~ /assets/
+                                    }
+
+    initializer "rails_customerbeats.add_middleware" do |app|
+      app.config.middleware.use RailsCustomerbeats::Middleware
+    end
+    
+    initializer "static assets" do |app|
+      app.middleware.insert_before ::ActionDispatch::Static, ::ActionDispatch::Static, "#{root}/public/assets"
+    end
+    
+    initializer "rails_customerbeats.set_ignores" do |app|
+      RailsCustomerbeats.ignore_lambdas.merge!(app.config.rails_customerbeats.ignore_lambdas)
+      RailsCustomerbeats.ignore_patterns.concat(app.config.rails_customerbeats.ignore_patterns)
+    end
+
+    initializer "rails_customerbeats.set_store" do |app|
+      if app.config.rails_customerbeats.set_store
+        RailsCustomerbeats.set_store(&app.config.rails_customerbeats.set_store)
+      end
+    end
+
+    initializer "rails_customerbeats.start_subscriber" do
+      ActiveSupport::Notifications.subscribe /[^!]$/ do |*args|
+        RailsCustomerbeats.events.push(args) if RailsCustomerbeats.valid_for_storing?(args)
+      end
+    end
+  end
+end

data/lib/rails_customerbeats/middleware.rb

@@ -0,0 +1,27 @@
+module RailsCustomerbeats
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if env["PATH_INFO"] =~ /^\/rails_customerbeats/
+        @app.call(env)
+      else
+        RailsCustomerbeats.listen_request do
+          response = notifications.instrument "rack.request",
+            :path => env["PATH_INFO"], :method => env["REQUEST_METHOD"],
+            :instrumenter_id => notifications.instrumenter.id do
+            @app.call(env)
+          end
+        end
+      end
+    end
+
+  protected
+
+    def notifications
+      ActiveSupport::Notifications
+    end
+  end
+end

data/lib/rails_customerbeats/orm/active_record.rb

@@ -0,0 +1,79 @@
+# Setup to ignore any query which is not a SELECT, INSERT, UPDATE
+# or DELETE and queries made by the own store.
+RailsCustomerbeats.ignore :invalid_queries do |name, payload|
+  name == "active_record.sql" &&
+    payload[:sql] !~ /^(SELECT|INSERT|UPDATE|DELETE)/
+end
+
+module RailsCustomerbeats
+  module ORM
+    # Include in your model to store metrics. For ActiveRecord, you need the
+    # following setup:
+    #
+    #   script/generate model Metric script/generate name:string duration:integer
+    #     request_id:integer parent_id:integer payload:text started_at:datetime created_at:datetime --skip-timestamps
+    #
+    # You can use any model name you wish. Next, you need to include
+    # RailsCustomerbeats::ORM::ActiveRecord:
+    #
+    #   class Metric < ActiveRecord::Base
+    #     include RailsCustomerbeats::ORM::ActiveRecord
+    #   end
+    #
+
+    ORM.primary_key_finder = :find
+    ORM.delete_all         = :delete_all
+
+    ORM.metric_model_properties = %w[
+      name:string
+      duration:integer
+      request_id:integer
+      parent_id:integer
+      payload:text
+      started_at:datetime
+      created_at:datetime
+    ]
+
+    def self.add_metric_model_config(generator, file_name, class_name)
+      generator.inject_into_class "app/models/#{file_name}.rb", class_name, <<-CONTENT
+        include RailsCustomerbeats::ORM::#{Rails::Generators.options[:rails][:orm].to_s.camelize}
+      CONTENT
+    end
+
+    module ActiveRecord
+      extend  ActiveSupport::Concern
+      include RailsCustomerbeats::Store
+
+      included do
+        # Create a new connection pool just for the given resource
+        establish_connection(Rails.env)
+
+        # Set required validations
+        validates_presence_of :name, :started_at, :duration
+
+        # Serialize payload data
+        serialize :payload
+
+        # Select scopes
+        scope :requests,      where(:name => "rack.request")
+        scope :by_name,       lambda { |name| where(:name => name) }
+        scope :by_request_id, lambda { |request_id| where(:request_id => request_id) }
+
+        # Order scopes
+        # We need to add the id in the earliest and latest scope since the database
+        # does not store miliseconds. The id then comes as second criteria, since
+        # the ones started first are first saved in the database.
+        scope :earliest, order("started_at ASC, id ASC")
+        scope :latest,   order("started_at DESC, id DESC")
+        scope :slowest,  order("duration DESC")
+        scope :fastest,  order("duration ASC")
+      end
+
+    protected
+
+      def save_metric!
+        save!
+      end
+    end
+  end
+end

data/lib/rails_customerbeats/orm/data_mapper.rb

@@ -0,0 +1,88 @@
+# Setup to ignore any query which is not a SELECT, INSERT, UPDATE
+# or DELETE and queries made by the own store.
+RailsCustomerbeats.ignore :invalid_queries do |name, payload|
+  name == "data_mapper.sql" &&
+    payload[:sql] !~ /^(SELECT|INSERT|UPDATE|DELETE)/
+end
+
+module RailsCustomerbeats
+  module ORM
+
+    # Include in your model to store metrics. For DataMapper, you need the
+    # following setup:
+    #
+    #   script/generate model Metric script/generate name:string duration:integer
+    #     request_id:integer parent_id:integer payload:object started_at:datetime created_at:datetime --skip-timestamps
+    #
+    # You can use any model name you wish. Next, you need to include
+    # RailsCustomerbeats::ORM::DataMapper:
+    #
+    #   class Metric
+    #     include DataMapper::Resource
+    #     include RailsCustomerbeats::ORM::DataMapper
+    #   end
+    #
+
+    ORM.primary_key_finder = :get
+    ORM.delete_all         = :destroy! # use bang version here cause we don't need no hooks
+
+    ORM.metric_model_properties = %w[
+      name:string
+      duration:integer
+      request_id:integer
+      parent_id:integer
+      payload:object
+      started_at:datetime
+      created_at:datetime
+    ]
+
+    def self.add_metric_model_config(generator, file_name, class_name)
+      generator.inject_into_file "app/models/#{file_name}.rb",
+        "  include RailsCustomerbeats::ORM::DataMapper\n",
+        {:after => "  include DataMapper::Resource\n"}
+    end
+
+    module DataMapper
+      extend  ActiveSupport::Concern
+      include RailsCustomerbeats::Store
+
+      included do
+        # Set required validations
+        validates_presence_of :name, :started_at, :duration
+      end
+
+      module ClassMethods
+
+        # Select scopes
+
+        def requests;                  all(:name       => 'rack.request') end
+        def by_name(name);             all(:name       => name          ) end
+        def by_request_id(request_id); all(:request_id => request_id    ) end
+
+        # Order scopes
+        # We need to add the id in the earliest and latest scope since the database
+        # does not store miliseconds. The id then comes as second criteria, since
+        # the ones started first are first saved in the database.
+
+        def earliest; all(:order => [:started_at.asc,  :id.asc ]) end
+        def latest;   all(:order => [:started_at.desc, :id.desc]) end
+        def slowest;  all(:order => [:duration.desc            ]) end
+        def fastest;  all(:order => [:duration.asc             ]) end
+
+      end
+
+      # Destroy all children if it's a request metric.
+      def destroy
+        self.class.by_request_id(self.id).destroy! if rack_request?
+        super
+      end
+
+    protected
+
+      def save_metric!
+        save!
+      end
+      
+    end
+  end
+end

data/lib/rails_customerbeats/payload_parser.rb

@@ -0,0 +1,134 @@
+module RailsCustomerbeats
+  # ActiveSupport::Notifications usually comes with extra information as the
+  # SQL query, response status and many others. This information is called payload.
+  #
+  # By default, RailsCustomerbeats stores the whole payload in the database but it allows
+  # you to manipulate it or even ignore some through the add and ignore methods.
+  #
+  # For example, "activerecord.sql" has as paylaod a hash with :name (like "Product
+  # Load"), the :sql to be performed and the :connection_id. We can remove the connection
+  # from the hash by simply providing :except:
+  #
+  #   RailsCustomerbeats::PayloadParser.add "active_record.sql", :except => :name
+  #
+  # Or, we could also:
+  #
+  #   RailsCustomerbeats::PayloadParser.add "active_record.sql", :slice => [:name, :sql]
+  #
+  # Finally, in some cases manipulating the hash is not enough and you might need
+  # to customize it further, as in "action_view.render_template". You can do
+  # that by giving a block which will receive the payload as argument:
+  #
+  #   RailsCustomerbeats::PayloadParser.add "action_view.render_template" do |payload|
+  #     payload = payload.dup
+  #     payload[:template] = payload[:template].gsub("RAILS_ROOT", Rails.root)
+  #     payload
+  #   end
+  #
+  # ATTENTION: if you need to modify the payload or any of its values, be sure to
+  # .dup if first, as in the example above.
+  #
+  # If you want to ignore any payload, you can use the ignore method:
+  #
+  #   RailsCustomerbeats::PayloadParser.ignore "active_record.sql"
+  #
+  module PayloadParser
+    # Holds the parsers used by RailsCustomerbeats.
+    def self.parsers
+      @parsers ||= {}
+    end
+
+    # Holds the mapped paths used in prunning.
+    def self.mapped_paths
+      @mapped_paths ||= {}
+    end
+
+    # Add a new parser.
+    def self.add(*names, &block)
+      options = names.extract_options!
+
+      names.each do |name|
+        parsers[name.to_s] = if block_given?
+          block
+        elsif options.present?
+          options.to_a.flatten
+        else
+          true
+        end
+      end
+    end
+
+    # Delete a previous parser
+    def self.ignore(*names)
+      names.each { |name| parsers[name.to_s] = false }
+    end
+
+    # Filter the given payload based on the name given and configured parsers
+    def self.filter(name, payload)
+      parser = parsers[name]
+      case parser
+      when Array
+        payload.send(*parser)
+      when Proc
+        parser.call(payload)
+      when TrueClass, NilClass
+        payload
+      when FalseClass
+        nil
+      end
+    end
+
+    # Prune paths based on the mapped paths set.
+    def self.prune_path(raw_path)
+      mapped_paths.each do |path, replacement|
+        raw_path = raw_path.gsub(path, replacement)
+      end
+      raw_path
+    end
+
+    # Make Rails.root appear as APP in pruned paths.
+    mapped_paths[Rails.root.to_s] = "RAILS_ROOT"
+
+    # Make Gem paths appear as GEM in pruned paths.
+    Gem.path.each do |path|
+      mapped_paths[File.join(path, "gems")] = "GEMS_ROOT"
+    end if defined?(Gem)
+
+    # ActiveRecord
+    add "sql.active_record" do |payload|
+      payload = payload.dup
+      payload[:sql] = payload[:sql].squeeze(" ")
+      payload.delete(:connection_id)
+      payload
+    end
+    
+     # ActionController - process action
+       add "process_action.action_controller" do |payload|
+       payload = payload.dup
+       #payload = payload.except(:path, :method, :params, :db_runtime, :view_runtime)
+       payload[:end_point] = "#{payload.delete(:controller)}##{payload.delete(:action)}"
+       #new_data = { 'session_id' => session.session_id , 'browser' => request.env['HTTP_USER_AGENT'] , 'ip_address' => request.env['REMOTE_ADDR'] }
+       #payload.merge!(new_data)
+       payload
+     end
+
+    # ActionView
+    add "render_template.action_view", "render_partial.action_view",
+        "render_collection.action_view" do |payload|
+      returning Hash.new do |new_payload|
+        payload.each do |key, value|
+          case value
+          when NilClass
+          when String
+            new_payload[key] = prune_path(value)
+          else
+            new_payload[key] = value
+          end
+        end
+      end
+    end
+
+    # ActionMailer
+    add "action_mailer.deliver", "action_mailer.receive", :except => :mail
+  end
+end

data/lib/rails_customerbeats/store.rb

@@ -0,0 +1,137 @@
+module RailsCustomerbeats
+  # This module contains the default API for storing notifications.
+  # Imagine that you configure your store to be the Metric class:
+  #
+  #   RailsCustomerbeats.set_store { Metric }
+  #
+  # Whenever a notification comes, RailsCustomerbeats instantiates a new
+  # store and call configure on it with the instrumentation arguments:
+  #
+  #   metric = Metric.new
+  #   metric.configure(args)
+  #   metric
+  #
+  # After all metrics are configured they are nested and save_metrics! is called,
+  # where each metric saves itself and its children.
+  #
+  # The method save_metrics! is implemented below and it requires the method
+  # save_metric! to be implemented in the target class.
+  #
+  module Store
+    VALID_ORDERS = %w(earliest latest slowest fastest).freeze
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def mount_tree(metrics)
+        while metric = metrics.shift
+          if parent = metrics.find { |n| n.parent_of?(metric) }
+            parent.children << metric
+          elsif metrics.empty?
+            return metric if metric.rack_request?
+            raise %(Expected tree root to be a "rack.request", got #{metric.name.inspect})
+          end
+        end
+      end
+
+      def events_to_metrics_tree(events)
+        verify_active_connections! if respond_to?(:verify_active_connections!)
+
+        metrics = events.map do |event|
+          metric = new
+          metric.configure(event)
+          metric
+        end
+
+        mount_tree(metrics)
+      end
+    end
+
+    # Configure the current metric by setting the values yielded by
+    # the instrumentation event.
+    def configure(args)
+      self.payload    = RailsCustomerbeats::PayloadParser.filter(args[0].to_s, args[4])
+      self.name       = args[0].to_s
+      self.started_at = args[1]
+      self.duration   = normalized_duration(self.payload, args)
+    end
+
+    def duration_in_us
+      self.duration
+    end
+
+    def duration_in_ms
+      self.duration * 0.001
+    end
+
+    def exclusive_duration
+      @exclusive_duration ||= self.duration - children.sum(&:duration)
+    end
+
+    def exclusive_duration_in_us
+      self.exclusive_duration
+    end
+
+    def exclusive_duration_in_ms
+      self.exclusive_duration * 0.001
+    end
+
+    # Stores the children of this metric when a tree is created.
+    def children
+      @children ||= []
+    end
+
+    def rack_request?
+      self.name == "rack.request"
+    end
+
+    # Returns if the current node is the parent of the given node.
+    # If this is a new record, we can use started_at values to detect parenting.
+    # However, if it was already saved, we lose microseconds information from
+    # timestamps and we must rely solely in id and parent_id information.
+    def parent_of?(node)
+      if !persisted?
+        start = (self.started_at - node.started_at) * 1000000
+        start <= 0 && (start + self.duration >= node.duration)
+      else
+        self.id == node.parent_id
+      end
+    end
+
+    def child_of?(node)
+      node.parent_of?(self)
+    end
+
+    # Save the current metric and all of its children by properly setting
+    # the request and parent ids.
+    def save_metrics!(request_id=nil, parent_id=nil)
+      self.request_id, self.parent_id = request_id, parent_id
+      save_metric!
+
+      children.each do |child|
+        child.save_metrics!(request_id || self.id, self.id)
+      end
+
+      unless self.request_id
+        self.request_id ||= self.id
+        save_metric!
+      end
+    end
+
+    # Destroy all children if it's a request metric.
+    def destroy
+      self.class.by_request_id(self.id).delete_all if rack_request?
+      super
+    end
+
+  protected
+
+    def save_metric!
+      raise NotImplementedError
+    end
+
+    def normalized_duration(payload, args)
+      payload[:duration] ? payload[:duration] : (args[2] - args[1]) * 1000000
+    end
+
+  end
+end

data/lib/rails_customerbeats/version.rb

@@ -0,0 +1,3 @@
+module RailsCustomerbeats
+  VERSION = "0.0.4"
+end

data/lib/rails_customerbeats.rb

@@ -0,0 +1,121 @@
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/class/attribute'
+
+Thread.abort_on_exception = Rails.env.development? || Rails.env.test?
+
+module RailsCustomerbeats
+  autoload :AsyncConsumer,    'rails_customerbeats/async_consumer'
+  autoload :Middleware,       'rails_customerbeats/middleware'
+  autoload :PayloadParser,    'rails_customerbeats/payload_parser'
+  autoload :Store,            'rails_customerbeats/store'
+  autoload :VERSION,          'rails_customerbeats/version'
+  autoload :VoidInstrumenter, 'rails_customerbeats/async_consumer'
+
+  module ORM
+    autoload :ActiveRecord, 'rails_customerbeats/orm/active_record'
+    autoload :DataMapper,   'rails_customerbeats/orm/data_mapper'
+
+    class << self
+      class_attribute :primary_key_finder
+      class_attribute :delete_all
+      class_attribute :metric_model_properties
+    end
+  end
+
+  # Set which store to use in RailsCustomerbeats.
+  #
+  #   RailsCustomerbeats.set_store { Metric }
+  #
+  def self.set_store(&block)
+    singleton_class.send :define_method, :store, &block
+  end
+
+  # Place holder for the store.
+  def self.store; end
+
+  # Holds the events for a specific thread.
+  def self.events
+    Thread.current[:rails_customerbeats_events] ||= []
+  end
+
+  # Turn RailsCustomerbeats on, i.e. make it listen to notifications during the block.
+  # At the end, it pushes notifications to the async consumer.
+  def self.listen_request
+    events = RailsCustomerbeats.events
+    events.clear
+
+    Thread.current[:rails_customerbeats_listening] = true
+    result = yield
+
+    RailsCustomerbeats.async_consumer.push(events.dup)
+    result
+  ensure
+    Thread.current[:rails_customerbeats_listening] = false
+    RailsCustomerbeats.events.clear
+  end
+
+  # Returns if events are being registered or not.
+  def self.listening?
+    Thread.current[:rails_customerbeats_listening] || false
+  end
+
+  # Allow you to specify a condition to ignore a notification based
+  # on its name and/or payload. For example, if you want to ignore
+  # all notifications with empty payload, one can do:
+  #
+  #   RailsCustomerbeats.ignore :with_empty_payload do |name, payload|
+  #     payload.empty?
+  #   end
+  #
+  # However, if you want to ignore something based solely on its
+  # name, you can use ignore_patterns instead:
+  #
+  #   RailsCustomerbeats.ignore_patterns << /^some_noise_plugin/
+  #
+  def self.ignore(name, &block)
+    raise ArgumentError, "ignore expects a block" unless block_given?
+    ignore_lambdas[name] = block
+  end
+
+  # Stores the blocks given to ignore with their respective identifier in a hash.
+  def self.ignore_lambdas
+    @@ignore_lambdas ||= {}
+  end
+
+  # Stores ignore patterns that can be given as strings or regexps.
+  def self.ignore_patterns
+    @@ignore_patterns ||= []
+  end
+
+  # Holds the queue which store stuff in the database.
+  def self.async_consumer
+    @@async_consumer ||= AsyncConsumer.new do |events|
+      next if events.empty?
+      root = RailsCustomerbeats.store.events_to_metrics_tree(events)
+      root.save_metrics!
+    end
+  end
+
+  # Wait until the async queue is consumed.
+  def self.wait
+    sleep(0.01) until async_consumer.finished?
+  end
+
+  # A notification is valid for storing if two conditions are met:
+  #
+  #   1) The instrumenter id which created the notification is not the same
+  #      instrumenter id of this thread. This means that notifications generated
+  #      inside this thread are stored in the database;
+  #
+  #   2) If the notification name does not match any ignored pattern;
+  #
+  def self.valid_for_storing?(args) #:nodoc:
+    name, payload = args[0].to_s, args[4]
+
+    RailsCustomerbeats.listening? && RailsCustomerbeats.store &&
+    !self.ignore_patterns.find { |p| String === p ? name == p : name =~ p } &&
+    !self.ignore_lambdas.values.any? { |b| b.call(name, payload) }
+  end
+end
+
+require 'rails_customerbeats/engine'

data/public/javascripts/rails_customerbeats/g.pie-min.js

@@ -0,0 +1,6 @@
+/* g.Raphael 0.4 - Charting library, based on Raphaël
+ * Copyright (c) 2009 Dmitry Baranovskiy (http://g.raphaeljs.com)
+ * Licensed under the MIT License.
+ * This code was modified by José Valim to not include "Others" neither sort values.
+ */
+Raphael.fn.g.piechart=function(d,c,n,b,k){k=k||{};var j=this,l=[],f=this.set(),m=this.set(),h=this.set(),t=[],v=b.length,w=0,x=0;m.covers=f;if(v==1){h.push(this.circle(d,c,n).attr({fill:this.g.colors[0],stroke:opt.stroke||"#fff","stroke-width":k.strokewidth==null?1:k.strokewidth}));f.push(this.circle(d,c,n).attr(this.g.shim));x=b[0];b[0]={value:b[0],order:0,valueOf:function(){return this.value}};h[0].middle={x:d,y:c};h[0].mangle=180}else{function s(C,B,i,E,A,J){var G=Math.PI/180,y=C+i*Math.cos(-E*G),p=C+i*Math.cos(-A*G),D=C+i/2*Math.cos(-(E+(A-E)/2)*G),I=B+i*Math.sin(-E*G),H=B+i*Math.sin(-A*G),z=B+i/2*Math.sin(-(E+(A-E)/2)*G),F=["M",C,B,"L",y,I,"A",i,i,0,+(Math.abs(A-E)>180),1,p,H,"z"];F.middle={x:D,y:z};return F}for(var u=0;u<v;u++){x+=b[u];b[u]={value:b[u],order:u,valueOf:function(){return this.value}}}for(var u=0;u<v;u++){var e=w-360*b[u]/x/2;if(!u){w=90-e;e=w-360*b[u]/x/2}if(k.init){var g=s(d,c,1,w,w-360*b[u]/x).join(",")}var q=s(d,c,n,w,w-=360*b[u]/x);var o=this.path(k.init?g:q).attr({fill:k.colors&&k.colors[u]||this.g.colors[u]||"#666",stroke:k.stroke||"#fff","stroke-width":(k.strokewidth==null?1:k.strokewidth),"stroke-linejoin":"round"});o.value=b[u];o.middle=q.middle;o.mangle=e;l.push(o);h.push(o);k.init&&o.animate({path:q.join(",")},(+k.init-1)||1000,">")}for(var u=0;u<v;u++){var o=j.path(l[u].attr("path")).attr(this.g.shim);k.href&&k.href[u]&&o.attr({href:k.href[u]});o.attr=function(){};f.push(o);h.push(o)}}m.hover=function(z,r){r=r||function(){};var y=this;for(var p=0;p<v;p++){(function(A,B,i){var C={sector:A,cover:B,cx:d,cy:c,mx:A.middle.x,my:A.middle.y,mangle:A.mangle,r:n,value:b[i],total:x,label:y.labels&&y.labels[i]};B.mouseover(function(){z.call(C)}).mouseout(function(){r.call(C)})})(h[p],f[p],p)}return this};m.each=function(y){var r=this;for(var p=0;p<v;p++){(function(z,A,i){var B={sector:z,cover:A,cx:d,cy:c,x:z.middle.x,y:z.middle.y,mangle:z.mangle,r:n,value:b[i],total:x,label:r.labels&&r.labels[i]};y.call(B)})(h[p],f[p],p)}return this};m.click=function(y){var r=this;for(var p=0;p<v;p++){(function(z,A,i){var B={sector:z,cover:A,cx:d,cy:c,mx:z.middle.x,my:z.middle.y,mangle:z.mangle,r:n,value:b[i],total:x,label:r.labels&&r.labels[i]};A.click(function(){y.call(B)})})(h[p],f[p],p)}return this};m.inject=function(i){i.insertBefore(f[0])};var a=function(E,z,r,p){var I=d+n+n/5,H=c,D=H+10;E=E||[];p=(p&&p.toLowerCase&&p.toLowerCase())||"east";r=j.g.markers[r&&r.toLowerCase()]||"disc";m.labels=j.set();for(var C=0;C<v;C++){var J=h[C].attr("fill"),A=b[C].order,B;E[A]=j.g.labelise(E[A],b[C],x);m.labels.push(j.set());m.labels[C].push(j.g[r](I+5,D,5).attr({fill:J,stroke:"none"}));m.labels[C].push(B=j.text(I+20,D,E[A]||b[A]).attr(j.g.txtattr).attr({fill:k.legendcolor||"#000","text-anchor":"start"}));f[C].label=m.labels[C];D+=B.getBBox().height*1.2}var F=m.labels.getBBox(),G={east:[0,-F.height/2],west:[-F.width-2*n-20,-F.height/2],north:[-n-F.width/2,-n-F.height-10],south:[-n-F.width/2,n+10]}[p];m.labels.translate.apply(m.labels,G);m.push(m.labels)};if(k.legend){a(k.legend,k.legendothers,k.legendmark,k.legendpos)}m.push(h,f);m.series=h;m.covers=f;return m};