riemann-feeds 0.0.1

data/README.md

@@ -0,0 +1,6 @@
+riemann-feeds
+=============
+
+A Ruby-based framework for Riemann event collectors ('feeds').
+
+Just a placeholder - coming soon.

data/lib/riemann-feeds.rb

@@ -0,0 +1,10 @@
+
+# riemann-feeds bootstrap
+
+require 'potrubi'
+
+require_relative  "riemann/feeds/mixin/standard"
+
+require_relative 'riemann/feeds/feed-handler.rb'
+
+__END__

data/lib/riemann/feeds/feed-handler.rb

@@ -0,0 +1,145 @@
+
+# riemann feed handler
+
+# manages feeds
+
+require_relative  "mixin/standard"
+require 'potrubi/mixin/contract-recipes'
+
+klassContent = Class.new do
+  
+  include Riemann::Feeds::Mixin::Standard
+  
+  # create the accessors with associated contracts
+
+  def self.feed_specification_keys
+    @feed_spec_keys ||= [:name, :type, :configuration]
+  end
+  
+  attrAccessors = {
+    ###:type => :string,
+    ###:name => :string,
+    ##feed: :hash,
+    feed_specification: {edit: {KEY_NAMES: 'self.class.feed_specification_keys'}, spec: :method_accessor_is_value_collection_with_keys},
+
+    #feed_specification_type: :symbol,
+    #feed_specification_name: :string,
+    #feed_specification_configuration: :hash,
+    
+    watch: :hash,
+    feed_instance: 'Riemann::Feeds::Type::Super', # all feeds must have this as superclass
+
+  }
+
+  Potrubi::Mixin::ContractRecipes.recipe_accessors(self, attrAccessors, :package_accessor_with_contract)
+
+  mustbeContracts = {
+    feed_name: :string,
+    feed_type: :symbol,
+    feed_config: :hash,
+  }
+
+  Potrubi::Mixin::ContractRecipes.recipe_mustbes(self, mustbeContracts)
+  
+  def initialize(feedArgs=nil, &feedBlok)
+    eye = 'rie::feed-hndl i'
+    
+    $DEBUG && logger_me(eye, "FEED HNDL INIT",  logger_fmt_kls(:feedArgs => feedArgs, :feedBlok => feedBlok))
+
+    super
+      
+    $DEBUG && logger_mx(eye, 'FEED HNDL INIT')
+    
+  end
+  
+
+  def make_watch_or_croak(watchArgs=nil, &watchBlok)
+    eye = :'rie::feed-hndl m_watch'
+    
+    $DEBUG && logger_me(eye, logger_fmt_kls(watchArgs: watchArgs),  logger_fmt_kls(watchBlok: watchBlok) )
+
+    ###mustbe_watch_handler_or_croak(watchArgs, eye, "watchArgs not really a watch handler")
+
+    ##watchWatch = watch
+    
+    ###mustbe_hash_or_croak(watchArgs, eye, "watchArgs not hash")
+
+    STOPBEFORMAKEWATCHRETURN
+    
+    nil
+  end
+
+    
+  def import_feed_or_croak(feedArgs)
+    eye = :'rie::feed-hndl imp_feed'
+    
+    $DEBUG && logger_me(eye, logger_fmt_kls(:feedArgs => feedArgs))
+
+    feedSpec = set_feed_specification(read_maybe_configuration_sources_list_or_croak(feedArgs).first) # set will apply contract
+
+    #STOPIMPFEED
+    
+    ###mustbe_subset_or_croak(feedSpec.keys, self.class.feed_specification_keys, eye) # check allowed keys
+    
+    feedName = mustbe_feed_name_key_or_croak(feedSpec, :name)
+    feedType = mustbe_feed_type_key_or_croak(feedSpec, :type)
+    feedConf = mustbe_feed_config_key_or_croak(feedSpec, :configuration)
+    
+    $DEBUG && logger_ms(eye, 'FEED', logger_fmt_kls(feedName: feedName, feedType: feedType, feedConf: feedConf))
+
+    feedKlass = find_feed_class_or_croak(feedType)
+    
+    feedInst = feedKlass.new(feedConf)
+
+    $DEBUG && logger_mx(eye, 'FEED', logger_fmt_kls(:feedName => feedName, :feedInst => feedInst))
+
+    set_feed_instance(feedInst)
+
+  end
+  
+
+  def find_feed_class_or_croak(feedType)
+    eye = :'rie::feed-hndl f_feed_kls'
+    
+    $DEBUG && logger_me(eye, logger_fmt_kls(:feedType => feedType))
+
+    feedKlass = case feedType
+                        when Class then feedType
+                        when Symbol then find_or_require_class_constant_or_croak("Riemann::Feeds::Type::#{feedType}")
+                        when String then find_or_require_class_constant_or_croak(feedType)
+                        else
+                          surprise_exception(feedType, eye, "feedType is what?")
+                        end
+    
+    
+    $DEBUG && logger_mx(eye, logger_fmt_kls(:feedType => feedType, :feedKlass => feedKlass))
+
+    mustbe_class_or_croak(feedKlass)
+    
+  end
+    
+    
+  def run_feed(runArgs=nil, &runBlok)
+    eye =  :'rie::feed-hndl r_feed'
+    eyeTale = 'RUN'
+    
+    $DEBUG && logger_me(eye, eyeTale,  logger_fmt_kls(:runArgs => runArgs, :runBlok => runBlok))
+
+    feedInst = find_feed_instance_or_croak
+    
+    feedInst.run(runArgs, &runBlok)
+
+    $DEBUG && logger_mx(eye, eyeTale,  logger_fmt_kls(:runArgs => runArgs, :runBlok => runBlok))
+    
+    self
+    
+  end
+
+end
+
+
+klassConstant = Potrubi::Core.assign_class_constant_or_croak(klassContent, :Riemann, :Feeds, :FeedHandler)
+
+__END__
+
+

data/lib/riemann/feeds/mixin/standard.rb

@@ -0,0 +1,37 @@
+
+# riemann feed mixin standard
+
+# includes all the usual mixins
+
+require 'potrubi/core'
+
+requireList = %w(initialize util persistence configuration)
+requireList.each {|r| require "potrubi/mixin/#{r}"}
+
+###["logger", "exceptions", "contracts"].each { |m| require_relative m }
+
+mixinContent = Module.new do
+
+  include Potrubi::Core
+  include Potrubi::Mixin::Initialize
+  include Potrubi::Mixin::Persistence
+  include Potrubi::Mixin::Configuration
+  include Potrubi::Mixin::Util
+
+  def initialize(initArgs=nil, &initBlok)
+    eye = :'rfms i'
+
+    $DEBUG && logger_me(eye, logger_fmt_kls_only(:initArgs => initArgs, :initBlok => initBlok))
+
+    super
+    
+    $DEBUG && logger_mx(eye, logger_fmt_kls_only(:initArgs => initArgs, :initBlok => initBlok))
+    
+  end
+
+end
+
+mixinConstant = Potrubi::Core.assign_module_constant_or_croak(mixinContent, :Riemann, :Feeds, :Mixin, :Standard)
+
+__END__
+

data/lib/riemann/feeds/type/jmx.rb

@@ -0,0 +1,536 @@
+# riemann feed jmx
+
+# Java Java Management Extensions (JMX) feed type
+
+###require "potrubi/mixin/util"
+require "potrubi/klass/syntax/braket"
+
+# simple way to disable JMX access
+
+
+JMX_LIVE_MODE = true
+#JMX_LIVE_MODE = false
+
+JMX_LIVE_MODE && (require "jmx4r") # does all the jmx heavy lifting
+
+require_relative "super"
+superClass = Riemann::Feeds::Type::Super
+
+###puts "RIEMAN FEED TPOE JMX SUPER >#{superClass.class}< >#{superClass}<"
+
+#stopHEREINJMX
+
+classContent = Class.new(superClass) do
+
+  ###include Potrubi::Mixin::Util
+
+  def self.feed_configuration_keys
+    @feed_configuration_keys ||= super.concat([:beans])
+  end
+
+  def self.bean_specification_keys
+    @bean_spec_keys ||= [:event_defaults, :attributes, :bean_name]
+  end
+  
+  def self.complex_attributes
+    #@complex_attributes ||= super.merge(beans: ->(k,v) {puts("\n\n\nBEAN IMPORT k >#{k}< v >#{v}<"); import_config_beans_or_croak(read_maybe_configuration_sources_or_croak({k => v}).values.first)})
+    @complex_attributes ||= super.merge(beans: ->(k,v) {import_config_beans_or_croak(read_maybe_configuration_sources_or_croak({k => v}).values.first)})
+  end
+
+  def self.simple_attributes
+    @simple_attributes ||= super.merge(Hash[*[:jmx_user, :jmx_pass, :jmx_host, :jmx_port, :jmx_connection].map {|a| [a, nil]}.flatten])
+  end
+  
+  # create the accessors with associated contracts
+  
+  attrAccessors = {
+    jmx_user: :string,
+    jmx_pass: :string,
+    jmx_host: :string,
+    ###:jmx_port => :string,
+    jmx_port: :fixnum,
+    #:jmx_connection => nil,
+    jmx_connection: 'JMX::MBeanServerConnectionProxy',
+
+    #beans_attributes: :hash,
+    beans_attributes: {edit: {KEY_TYPE: :string, VALUE_TYPE: :attributes_definitions}, spec: :method_accessor_is_value_typed_collection},
+
+    #beans_specifications: :hash,
+    beans_specifications: {edit: {KEY_TYPE: :string, VALUE_TYPE: :bean_specification, VALUE_IS_NIL_RESULT: 'true'}, spec: :method_accessor_is_value_typed_collection},
+
+    
+  }
+
+  Potrubi::Mixin::ContractRecipes.recipe_accessors(self, attrAccessors, :package_accessor_with_contract)
+
+  #STOPHEREJMXATTS
+  
+  mustbeContracts = {
+    beans_container: :array,  # just the container
+    bean_name: :string,
+    #bean_spec: :hash,
+    bean_specification: {edit: {KEY_NAMES: 'self.class.bean_specification_keys'}, spec: :method_mustbe_is_value_collection_with_keys},
+    ###bean_attributes: :hash,
+    bean_attributes_with_metrics: :hash,
+    jmx_bean: 'JMX::MBean',
+    bean_attributes_specification: :hash,
+    jmx_bean_attributes: {edit: {KEY_TYPE: :string, VALUE_TYPE: :string}, spec: :method_mustbe_is_value_typed_collection},
+    jmx_bean_attributes_with_metrics: {edit: {KEY_TYPE: :string, VALUE_TYPE: :string}, spec: :method_mustbe_is_value_typed_collection},
+  }
+
+  Potrubi::Mixin::ContractRecipes.recipe_mustbes(self, mustbeContracts)
+
+  #STOPHEREJMXMUSTBES
+
+ # def self.simple_attributes
+ #   @simple_attributes ||= super.concat([:event_defaults])
+ # end
+
+  def jmx_connection # override the one made by the recipe
+    @jmx_connection ||=  open_jmx_connection_or_croak
+  end
+  
+  def import_config_beans_or_croak(beanArgs, &beanBlok)
+    eye = :'rftj imp_cfg_beans'
+
+    $DEBUG && logger_me(eye, logger_fmt_kls(beanArgs: beanArgs, beanBlok: beanBlok))
+
+    #STOPBEENARAGSB4VALIDATION
+
+    mustbe_beans_container_or_croak(beanArgs, eye) # jsut an array right now
+
+    #puts("\n\n\n\nBEAN ARGS >#{beanArgs.class}< >#{beanArgs}<")
+    
+    # resolved external configuration
+    # afterwards, treat bare strings as bean name and gfake up a hash
+    
+    #beansHashes = read_maybe_configuration_sources_list_or_croak(*beanArgs).map {|h| puts("\n\n\n\n\n\nIMPCFGBEAN h >#{h.class}< >#{h}<"); h.is_a?(String) ? {bean_name: h} : h}
+    beansHashes = read_maybe_configuration_sources_list_or_croak(*beanArgs).map {|h| h.is_a?(String) ? {bean_name: h} : h}
+    mustbe_bean_specifications_or_croak(*beansHashes)  
+
+    beansSpecs = self.beans_specifications = potrubi_util_array_to_hash(beansHashes) {|v| [mustbe_bean_name_key_or_croak(v, :bean_name), read_maybe_configuration_sources_or_croak(v)] }
+    
+    #STOPBEENARAGSAFVALIDATION
+    
+    beanObjs = []
+
+    #beanSpecDefault = {}
+    ##beanSpecDefault = nil
+    
+    self.beans_attributes = beansAttrs = make_beans_attributes_definitions_or_croak(beansSpecs, &beanBlok)  # preserve full atributes map
+
+    beansMths = make_beans_attributes_methods_or_croak(beansAttrs)
+    
+    $DEBUG && logger_mx(eye, logger_fmt_kls(beansMths: beansMths))
+
+    beansMths
+    
+  end
+  
+  def make_beans_attributes_definitions_or_croak(beansSpecs, &beanBlok)
+    eye = :'m_beans_attrs_defs'
+    eyeTale = 'BEAN ATTRS DEFS'
+    
+    $DEBUG && logger_me(eye, eyeTale, logger_fmt_kls(beansSpecs: beansSpecs, beanBlok: beanBlok))
+
+    mustbe_beans_specifications_or_croak(beansSpecs, eye, "beansSpecs not hash")
+
+    #STOPHEREBEANSATTRSSPECS
+
+    beanSpecDefault = nil  # what to do / use this for?
+
+    beansAttrs = potrubi_util_map_hash_v(beansSpecs) do | beanName, beanSpecNom |
+
+      $DEBUG && logger_beg(eye, eyeTale, logger_fmt_kls(beanName: beanName, :beanSpecNom => beanSpecNom))
+      
+      beanSpec = potrubi_util_merge_hashes_or_croak(beanSpecDefault, beanSpecNom) # any defaults?
+
+      ###attrSpec = make_bean_attrs_specs_or_croak(:bean_name => beanName, :bean_spec => beanSpec)
+
+      attrDefsNom = mustbe_hash_key_or_nil_or_croak(beanSpec, :attributes, eye, "attribute not hash")
+
+      $DEBUG && logger_ms(eye, eyeTale, 'ATTRS NOM', logger_fmt_kls(beanName: beanName, :attrDefsNom => attrDefsNom))
+
+      ###STOPHEREATARRTDEFSNOM
+      
+      JMX_LIVE_MODE && (attrAll = find_jmx_bean_attributes_with_metrics_or_croak(beanName).keys)
+      JMX_LIVE_MODE || (attrAll = mustbe_hash_key_or_nil_or_croak(attrDefsNom, :definitions, eye, "TESTING attributes map not hash").keys)
+
+      attrDefsNrm = potrubi_util_merge_hashes_or_croak({:all => attrAll}, attrDefsNom)
+
+      $DEBUG && logger_ms(eye, eyeTale, 'ATTRS NRM', logger_fmt_kls(beanName: beanName, :attrDefsNrm => attrDefsNrm))
+      
+      attrsDefs  = make_attributes_definitions_or_croak(attrDefsNrm)
+
+      $DEBUG && logger_fin(eye, eyeTale, logger_fmt_kls(beanName: beanName, :attrsDefs => attrsDefs))
+
+      attrsDefs
+    end
+    
+    $DEBUG && logger_mx(eye, eyeTale, logger_fmt_kls(beansSpecs: beansSpecs, beansAttrs: beansAttrs))
+
+    mustbe_hash_or_croak(beansAttrs, eye, "beansAttrs not hash")
+
+    #STOPMAKEBEENASATTARSDEFS
+    
+  end
+
+  def make_beans_attributes_methods_or_croak(beansAttrs, &beanBlok)
+    eye = :'rftj m_beans_attrs_mths'
+
+    $DEBUG && logger_me(eye, logger_fmt_kls(:beansAttrs => beansAttrs, beanBlok: beanBlok))
+
+    #STOPHEREBEASNATTRSMTHS
+    
+    mustbe_beans_attributes_or_croak(beansAttrs, eye, "beansAttrs failed contract")
+
+    #STOPMAKEBEASNATTRSMTHS
+    
+    beansMths = make_syntax_beans_methods_or_croak(beansAttrs)
+    
+    $DEBUG && logger_ms(eye, 'BEANS MTHS', logger_fmt_kls(beansMths: beansMths))
+
+    ##STOPHEREBEANSMTHS
+
+    beansDyns = beansMths.values.inject({}) {|s,h| s.merge(h) }  # flatten values
+
+    $DEBUG && logger_ms(eye, 'BEANS DYNS', logger_fmt_kls(beansDyns: beansDyns))
+    
+    # get the singleton class
+
+    singletonKls = class << self; self; end
+
+    Potrubi::Core.dynamic_define_methods(singletonKls, beansDyns) # make beans methods in singleton class
+    
+    $DEBUG && logger_mx(eye, logger_fmt_kls(beansDyns: beansDyns))
+
+    beansDyns
+    
+  end
+  
+  # Method Syntax
+  # #############
+
+  def make_syntax_beans_methods_or_croak(beansAttrs, &beanBlok)
+    eye = :'rftj ms_beans_mths'
+
+    $DEBUG && logger_me(eye, logger_fmt_kls(beansAttrs: beansAttrs, beanBlok: beanBlok))
+
+    mustbe_hash_or_croak(beansAttrs, eye, "beansAttrs not hash")
+
+    beansMths = potrubi_util_map_hash_v(beansAttrs) { | beanName, beanAttrs | collect_attributes_method_definitions_or_croak(beanAttrs) }
+    
+    #mtdSpec = {:bean_name => beanName, :bean_spec => beanAttrs}
+
+    beansMths[:each_event] = {each_event: make_syntax_each_event_method_or_croak(beansAttrs).to_s}
+    
+    $DEBUG && logger_ms(eye, logger_fmt_kls(beansAttrs: beansAttrs), logger_fmt_kls_only(beansMths: beansMths))
+
+    mustbe_hash_or_croak(beansMths, eye, "beansMthds not hash")
+
+  end
+  
+
+  def make_syntax_each_event_method_or_croak(beansAttrs, &mthBlok)
+    eye = :'rftj ms_each_evt_mtd'
+    eyeTale = 'EACH_EVENT'
+
+    $DEBUG && logger_me(eye, eyeTale, logger_fmt_kls(beansAttrs: beansAttrs, :mthBlok => mthBlok))
+
+    mustbe_beans_attributes_or_croak(beansAttrs, eye, "beansAttrs not a beans_attributes")
+    
+    braketKls = Potrubi::Klass::Syntax::Braket # class to simplify method text construction
+
+    braketMethod = braketKls.new_method  # will hold to_events method's syntax
+    
+    braketMethod.cons_head('def each_event',
+                           ####JMX_LIVE_MODE && 'jmxConn = find_jmx_connection_or_croak',
+                           ###JMX_LIVE_MODE && 'jmxConn = find_jmx_connection_or_croak',
+                           ###'beansAttrs = beans_attributes',
+                           ###'evntIter = Enumerator.new do | enum |',  # make a lazy enumerator
+                           )
+    
+    braketMethod.push_tail(###'end',
+                           ####JMX_LIVE_MODE && 'close_jmx_connection_or_croak(jmxConn)',
+                           ###'$DEBUG && logger_ca(:to_evnts, "evntIter >#{evntIter.class}<")',
+                           ###'evntIter',
+                           'self',
+                           'end')
+    hostDefaults = {host: jmx_host} #  need to specify source of the events
+    eventDefaults = event_defaults
+    beansSpecifications = find_beans_specifications_or_croak
+    
+    braketsBeans = beansAttrs.each_with_object([]) do | (beanName, attrsSpecs), a |
+
+      $DEBUG && logger_beg(eye, eyeTale, 'BEAN', logger_fmt_kls(beanName: beanName, :attrsSpecs => attrsSpecs))
+
+      beaneventDefaults = mustbe_event_defaults_key_or_nil_or_croak(beansSpecifications[beanName], :event_defaults, eye, "beanName >#{beanName}< event defaults not hash")
+
+      mustbe_bean_attributes_specification_or_croak(attrsSpecs, eye, "attrsSpecs not hash")
+
+      braketBean = braketKls.new_stanza  # will hold syntax for this bean
+
+      braketBean.cons(JMX_LIVE_MODE && "beanInst = find_jmx_bean_or_croak('#{beanName}')")
+      
+      attrsSpecs.each do | attrName, attrSpec |
+
+        $DEBUG && logger_beg(eye, eyeTale, 'BEAN ATTR', logger_fmt_kls(beanName: beanName, :attrName => attrName, :attrSpec => attrSpec))
+
+        attrPassThru = mustbe_hash_key_or_nil_or_croak(attrSpec, :pass_thru, eye, "pass thru not hash")
+
+        attreventDefaults = mustbe_event_defaults_key_or_nil_or_croak(attrPassThru, :event_defaults, eye, "beanName >#{beanName}< attrName >#{attrName}< event defaults not hash")
+
+        $DEBUG && logger_ms(eye, eyeTale, 'BEAN ATTR PASS & DEFS', logger_fmt_kls(:passThru => attrPassThru, :attrDefaulst => attreventDefaults))
+  
+        defaultFields = merge_event_hashes(hostDefaults, eventDefaults, beaneventDefaults, attreventDefaults)
+
+        #  Build the event hash with the wanted attribute (event) fields
+        
+        attrDefs = {metric: "beanInst.#{attrName}", description: "'#{attrName}'"}
+        JMX_LIVE_MODE || (attrDefs = {:metric => "2.97", :description => "'#{attrName}'"}) # TESING
+
+        # Create the syntax for the attributes in attrDefs, with normalisation calls if any
+        
+        attrFields = attrDefs.each_with_object({}) do | (fieldName, fieldDef), h |
+          fieldBraket = braketKls.new_statement.push(fieldDef) # add the field def 
+          (fieldSpec = attrSpec[fieldName]) && fieldBraket.cons_head(fieldSpec[:method_name], '(').push_tail(')')                                      
+          h[fieldName] = fieldBraket.to_s
+        end
+        
+        eventFields = merge_event_hashes(defaultFields, attrSpec[:event_defaults], attrFields)
+
+        # Convert the event to text representation - needs custom logic
+        
+        braketEvent = eventFields.inject(braketKls.new_statement) do | bkt, (fieldName, fieldValue) |
+          r = case fieldName
+              when :metric, :description then fieldValue
+              when :tags then fieldValue  # array to.s is fine
+              else
+                "'#{fieldValue}'"  # enclose in single quotes
+              end
+          bkt.push(fieldName, ': ', r.to_s, ', ') # short form symbol key syntax 
+        end
+
+        braketEvent.pop  # get rid of last comma
+        
+        braketEvent.cons_head('{').push_tail('}') # hash syntax
+
+        ###braketEvent.raw_debug("BRAKET FIELDS")
+        ###puts("BRAKETFIELDS >#{braketEvent}<")
+        
+        ###STOPHEREAFTERATTRFIELDS
+
+        # Is the event hash to be transformed (mapped)?
+
+        braketTransform = case (transformSpec = attrSpec[:map])
+                          when NilClass then braketEvent
+                          else
+                            #bkt = braketKls.new_statement
+                            #bkt.cons_head(transformSpec[:method_name], '(').push_tail(')')
+                            #bkt.push(braketEvent)
+                            #bkt
+                            braketKls.new_statement.cons_head(transformSpec[:method_name], '(').push_tail(')').push(braketEvent)
+                          end
+
+        # Construct the yield
+
+        ###braketYield = braketKls.new_statement.cons_head('enum.yield(').push_tail(')')
+        braketYield = braketKls.new_statement.cons_head('yield(').push_tail(')')
+
+        # Is event to be filtered (selected)?
+        
+        braketAttr = case (filterSpec = attrSpec[:select])
+                     when NilClass then braketYield.push(braketTransform) # no filter
+                     else
+                       bkt = braketKls.new_statement
+                       bkt.push('(r = ', braketTransform, ')')
+                       bkt.push(' && ', filterSpec[:method_name], '(r)')
+                       bkt.push(' && ', braketYield.push('r'))
+                       bkt
+                     end
+
+        braketBean.push(braketAttr)
+        
+        $DEBUG && logger_fin(eye, eyeTale, 'BEAN ATTR', logger_fmt_kls(:attrName => attrName, :attrSpec => attrSpec))
+
+      end
+
+      a << braketBean
+
+      $DEBUG && logger_fin(eye, eyeTale, 'BEAN', logger_fmt_kls(beanName: beanName, :attrsSpecs => attrsSpecs))
+
+    end
+
+    braketMethod.push(braketsBeans)
+    
+    ###braketMethod.raw_debug('TO_EVENT METHOD')
+    $DEBUG && puts("EACH_EVENT METHOD \n>#{braketMethod.to_s}<")
+    
+    ###STOPHERETOEVENTS
+
+    $DEBUG && logger_me(eye, eyeTale, logger_fmt_kls_only(beansAttrs: beansAttrs, :braketMethod => braketMethod))
+
+    braketMethod
+
+
+  end
+
+  
+
+
+  # Bean Finders
+  # ############
+  
+  def find_jmx_bean_attributes_or_croak(beanName, &beanBlok)
+    eye = :'rftj f_bean_attrs'
+    beanAttrs = find_jmx_bean_or_croak(beanName).attributes
+    $DEBUG && logger_ca(eye, logger_fmt_kls(beanName: beanName, beanAttrs: beanAttrs))
+    mustbe_jmx_bean_attributes_or_croak(beanAttrs, eye, "beanAttrs failed contract")
+  end
+
+  def find_jmx_bean_attributes_with_metrics_or_croak(beanName, &beanBlok)
+    eye = :'rftj f_bean_attrs_w_metrics'
+    metricsRegex = Regexp.new('\Atag\.')
+    beanAttrsWithMetrics = find_jmx_bean_attributes_or_croak(beanName).select {|k,v| ! k.match(metricsRegex) }
+    $DEBUG && logger_ca(eye, logger_fmt_kls(beanName: beanName, beanAttrsWithMetrics: beanAttrsWithMetrics))
+    mustbe_jmx_bean_attributes_with_metrics_or_croak(beanAttrsWithMetrics, eye, "beanAttrsWithMetrics failed contract")
+  end
+
+  def find_jmx_bean_or_croak(beanName, &beanBlok)
+    eye = :'rftj f_bean'
+    $DEBUG && logger_me(eye, logger_fmt_kls(beanName: beanName, beanBlok: beanBlok))
+    beanConn = find_jmx_connection_or_croak
+    beanInst = JMX::MBean.find_by_name(beanName, :connection => beanConn)
+    $DEBUG && logger_mx(eye, logger_fmt_kls(beanName: beanName, :beinInst => beanInst, :beanConn => beanConn))
+    mustbe_jmx_bean_or_croak(beanInst, eye, 'jmx bean find failed')
+  end
+
+  # JMX Connections
+  # ###############
+
+  
+  def open_jmx_connection_or_croak(jmxArgs={}, &jmxBlok)
+    eye = :'rftj o_jmx_conn'
+
+    jmxHost = mustbe_jmx_host_key_or_nil_or_croak(jmxArgs, :jmx_host, eye) || find_jmx_host_or_croak
+    jmxPort = mustbe_jmx_port_key_or_nil_or_croak(jmxArgs, :jmx_port, eye) || find_jmx_port_or_croak
+    jmxUser = mustbe_jmx_user_key_or_nil_or_croak(jmxArgs, :jmx_user, eye) || jmx_user
+    jmxPass = mustbe_jmx_pass_key_or_nil_or_croak(jmxArgs, :jmx_pass, eye) || jmx_pass
+
+    jmxConn = begin
+
+                 case
+                 when jmxUser.nil? then JMX::MBean.establish_connection(:host => jmxHost, :port => jmxPort)
+                 else
+                   JMX::MBean.establish_connection(:host => jmxHost, :port => jmxPort, :username => jmxUser, :password => jmxPass)
+                 end
+                 
+               rescue Exception => e
+                 errorText = "Connection open error: jmxArgs >#{jmxArgs}< jmxHost >#{jmxHost}< jmxPort >#{jmxPort}< jmxUser >#{jmxUser}< error >#{e.message}"
+                 #riemann_alert
+                 connection_exception(e, errorText)
+               end
+    
+    $DEBUG && logger_mx(eye, logger_fmt_kls(:jmxArgs => jmxArgs, :jmxConn => jmxConn))
+
+    self.jmx_connection = jmxConn # contract will validate it
+
+  end  
+  
+
+  def close_jmx_connection_or_croak(jmxArgs={}, &jmxBlok)
+    eye = :'rftj cl_jmx_conn'
+
+    jmxConn = mustbe_jmx_connection_key_or_nil_or_croak(jmxArgs, :jmx_connection, eye) || (jmxConnAccessor = jmx_connection)
+
+    jmxConn && begin
+                 jmxConn.close
+                 (jmxConn == jmxConnAccessor) && reset_jmx_connection # reset accessor if same
+               rescue Exception => e
+                 errorText = "Connection close error: jmxArgs >#{jmxArgs}< jmxHost >#{jmxHost}< jmxPort >#{jmxPort}< jmxUser >#{jmxUser}< error >#{e.message}"
+                 #riemann_alert
+                 connection_exception(e, errorText)
+               end
+    
+    $DEBUG && logger_mx(eye, logger_fmt_kls(:jmxArgs => jmxArgs, :jmxConn => jmxConn))
+
+    self
+
+  end  
+  
+end
+
+klassConstant = Potrubi::Core.assign_class_constant_or_croak(classContent, :Riemann, :Feeds, :Type, :JMX)
+
+###puts "RIEMANN FEED TYPE JMX >#{klassConstant.class}< >#{klassConstant}<"
+
+__END__
+
+
+
+
+
+
+  def zzzmake_syntax_bean_methods_or_croak(beanArgs, &beanBlok)
+    eye = :'rftj ms_bean_mths'
+
+    $DEBUG && logger_me(eye, logger_fmt_kls(beanArgs: beanArgs, beanBlok: beanBlok))
+
+    beanName = mustbe_string_key_or_croak(beanArgs, :bean_name, eye, "beanName not string")
+    beanAttrs = mustbe_hash_key_or_croak(beanArgs, :bean_attrs, eye, "beanAttrs not hash")
+
+    beanMths = collect_attribute_method_definitions_or_croak(beanAttrs)
+
+    $DEBUG && logger_mx(eye, logger_fmt_kls(beanArgs: beanArgs), logger_fmt_kls(:beanMtds => beanMths))
+
+    mustbe_hash_or_croak(beanMths, eye, "beanMths not hash")
+
+    ##STOPEHEREATTR
+
+  end
+  
+jmxConstants = klassConstant.constants(false)
+
+puts "RIEMANN FEED TYPE JMX CONSTANTS >#{jmxConstants.class}< >#{jmxConstants}<"
+
+jmxConstants.each do |c|
+  v = klassConstant.const_get(c, false)
+  puts "RIEMANN FEED TYPE JMX CONSTANT c >#{c}< v >#{v.class}< >#{v}<"
+end
+
+
+  def make_bean_attrs_specs_or_croak(beanArgs, &beanBlok)
+    eye = :'rftj m_bean_attrs_specs'
+
+    $DEBUG && logger_me(eye, logger_fmt_kls(beanArgs: beanArgs, beanBlok: beanBlok))
+
+    STOPMAKEBEANATTRSSPECS
+
+    
+    beanSpec = mustbe_bean_spec_or_nil_or_croak(beanArgs[:bean_spec], eye, "beanSpec failed contract") || {}
+    beanName = mustbe_bean_name_or_croak(beanArgs[:bean_name], eye, "beanName failed contract")
+    
+    $DEBUG && logger_ms(eye, logger_fmt_kls(beanName: beanName, :beanSpec => beanSpec))
+    
+    attrDefsNom = mustbe_hash_key_or_nil_or_croak(beanSpec, :attributes, eye, "attribuste not hash")
+
+    $DEBUG && logger_ms(eye, 'BEAN ATTRS NOM', logger_fmt_kls(:attrDefsNom => attrDefsNom))
+
+    ###STOPHEREATARRTDEFSNOM
+    
+    JMX_LIVE_MODE && (attrAll = find_jmx_bean_attributes_with_metrics_or_croak(beanName).keys)
+    JMX_LIVE_MODE || (attrAll = mustbe_hash_key_or_nil_or_croak(attrDefsNom, :definitions, eye, "TESTING attributes map not hash").keys)
+
+    attrDefsNrm = potrubi_util_merge_hashes_or_croak({:all => attrAll}, attrDefsNom)
+
+    $DEBUG && logger_ms(eye, 'BEAN ATTRS NRM', logger_fmt_kls(:attrDefsNrm => attrDefsNrm))
+    
+    beanAttrs = make_attribute_specs_or_croak(attrDefsNrm)
+
+    ##SOPTPOSMAKEATTRSPECS
+    
+    $DEBUG && logger_mx(eye, logger_fmt_kls(beanName: beanName, :beanAttrs => beanAttrs))
+
+    mustbe_hash_or_croak(beanAttrs, "beanName >#{beanName}< beanAttrs not hash")
+    
+  end

data/lib/riemann/feeds/type/super.rb

@@ -0,0 +1,328 @@
+# riemann feed super
+
+# common methods for all feeder types
+
+require 'potrubi/mixin/contract-recipes'
+
+require_relative "../mixin/standard"
+
+require 'riemann/client'
+
+classContent = Class.new do
+
+  ###include Potrubi::Mixin::Util
+  include Riemann::Feeds::Mixin::Standard
+
+  def self.attributes_specification_keys
+    @attributes_specification_keys ||= [:include, :exclude, :definitions, :all]
+  end
+
+  def self.attributes_definition_keys
+    @feed_attribute_definition_keys ||= [:map, :select, :metric, :pass_thru, :event_defaults]
+  end
+
+  def self.event_fields
+    @event_fields ||= [:host, :service, :status, :time, :ttl,  :tags, :description, :metric]
+  end
+
+  def self.feed_configuration_keys
+    @feed_configuration_keys ||= [:include_configuration, :event_defaults] # likely be subclassed
+  end
+
+  # Complex, simple and all attributes are hashes
+  
+  def self.complex_attributes
+    @complex_attributes ||= {
+      include_configuration: ->(k,v) {self.set_attributes_from_configuration_sources_list_or_croak(*v)},
+    }
+  end
+
+  def self.simple_attributes
+    @simple_attributes ||= Hash[*[:event_defaults, :riemann_host, :riemann_port, :riemann_interval].map {|a| [a, nil]}.flatten]
+  end
+
+  def self.all_attributes
+    @all_attributes ||= complex_attributes.merge(simple_attributes)
+  end
+  
+  attrAccessors = {
+    riemann_host: :string,
+    riemann_port: :fixnum,
+    riemann_interval: :fixnum,
+    event_defaults: {edit: {KEY_NAMES: 'self.class.event_fields'}, spec: :method_accessor_is_value_collection_with_keys},
+    feed_configuration: {edit: {KEY_NAMES: 'self.class.all_attributes.keys'}, spec: :method_accessor_is_value_collection_with_keys},
+  }
+
+  Potrubi::Mixin::ContractRecipes.recipe_accessors(self, attrAccessors, :package_accessor_with_contract)
+
+  mustbeContracts = {
+    attributes_specification: {edit: {KEY_TYPE: :symbol, VALUE_TYPE: :any, KEY_NAMES: 'self.class.attributes_specification_keys'}, spec: :method_mustbe_is_value_typed_collection_with_keys},
+
+    attributes_specification_all: {edit: {VALUE_TYPE: :string}, spec: :method_mustbe_is_value_typed_array},
+    attributes_specification_include: {edit: {VALUE_TYPE: :string}, spec: :method_mustbe_is_value_typed_array},
+    attributes_specification_exclude: {edit: {VALUE_TYPE: :string}, spec: :method_mustbe_is_value_typed_array},
+
+    attributes_definitions: {edit: {KEY_TYPE: :string, VALUE_TYPE: :attributes_definition_map}, spec: :method_mustbe_is_value_typed_collection},
+    attributes_definition_map: {edit: {KEY_NAMES: 'self.class.attributes_definition_keys'}, spec: :method_mustbe_is_value_collection_with_keys},
+  }
+
+  Potrubi::Mixin::ContractRecipes.recipe_mustbes(self, mustbeContracts)
+  
+  #STOPHEREAFTERSUPERCONTRACTS
+  
+  def initialize(initArgs=nil, &initBlok)
+    eye = :'rfts i'
+
+    $DEBUG && logger_me(eye, logger_fmt_kls_only(:initArgs => initArgs, :initBlok => initBlok))
+
+    initArgs && import_configuration_or_croak(initArgs)
+
+    #initArgs && mustbe_hash_or_croak(initArgs, eye).each {|k, v| __send__("#{k}=", v) }
+    
+    Kernel.block_given? && instance_eval(&initBlok)
+
+  end
+
+  def import_configuration_or_croak(feedConf=nil, &feedBlok)
+    eye = :'rfts imp_cfg'
+
+    $DEBUG && logger_me(eye, logger_fmt_kls(:feedConf => feedConf, :feedBlok => feedBlok))
+
+    mustbe_feed_configuration_or_croak(feedConf, eye, "feedConf failed contract")
+    
+    set_attributes_using_specification_or_croak(self.class.all_attributes, feedConf)
+
+    $DEBUG && logger_mx(eye, logger_fmt_kls_only(:feedConf => feedConf, :feedBlok => feedBlok))
+
+    self
+    
+  end
+  
+  def to_event(*eventHashes)
+    eventHash = potrubi_util_merge_hashes_or_croak(*eventHashes)
+    mustbe_subset_or_croak(eventHash.keys, self.class.event_fields, eye, "unknown event keys / fields")
+    eventHash
+  end
+
+  def merge_event_hashes(*eventHashes)
+
+    mergeHash = eventHashes.inject({}) do | hashSumm, eventHash |
+
+      case eventHash
+      when NilClass then hashSumm # this is ok; convenient to allow nil
+      when Hash
+
+        ###print("MEREG EVENT HASHES hashSumm >#{hashSumm}< eventHash >#{eventHash}\n\n\n")
+        
+        r = hashSumm.merge(eventHash.select {|k,v| (k != :tags) })
+
+        r[:tags] = merge_event_tags(hashSumm[:tags], eventHash[:tags])
+
+        r
+
+      else
+        surprise_exception(eventHash, :m_evts_hshs, "eventHash not hash")
+      end
+      
+    end
+
+    $DEBUG && logger_ca(:m_evts_hshs, logger_fmt_kls(:mergeHash => mergeHash))
+    
+    mergeHash
+
+    ###STOPMERGEHASHES
+    
+  end
+
+  def merge_event_tags(*eventTags)
+    mergeTags = eventTags.inject([]) do | tagsSumm, eventTags |
+
+      case eventTags
+      when NilClass then tagsSumm # this is ok; convenient to allow nil
+      when Array then tagsSumm.concat(eventTags)
+      else
+        surprise_exception(eventTags, :m_evts_tags, "eventTags not array")
+      end
+
+    end
+
+    $DEBUG && logger_ca(:m_evts_tags, logger_fmt_kls(:mergeTags => mergeTags))
+    
+    mergeTags
+  end
+
+    # These from Riemann Tools, modified
+
+  def run(runArgs=nil, &runBlok)
+    eye = 'rfms r'
+
+    $DEBUG && logger_me(eye, logger_fmt_kls(:runArgs => runArgs, :runBlok => runBlok))
+    
+    ###mustbe_hash_or_nil_or_croak(runArgs, eye, "runArgs not hash")
+
+    tickInterval = mustbe_fixnum_key_or_nil_or_croak(runArgs, :interval, eye, "run interval not fixnum") || find_riemann_interval_or_croak
+    
+    t0 = Time.now
+    
+    loop do
+      
+      begin
+        riemann_tick
+      rescue => e
+        $stderr.puts "#{e.class} #{e}\n#{e.backtrace.join "\n"}"
+        break
+      end
+
+      sleep(tickInterval - ((Time.now - t0) % tickInterval))  # Sleep. 
+      
+    end
+
+    $DEBUG && logger_mx(eye, logger_fmt_kls(:runArgs => runArgs))
+
+    self
+    
+  end
+
+  def riemann_client
+    @riemann_client ||= Riemann::Client.new(
+                                            :host => find_riemann_host_or_croak,
+                                            :port => find_riemann_port_or_croak,
+                                            )
+  end
+  
+  def riemann_tick
+
+    r = riemann_client
+
+    if (! $DEBUG)
+      each_event {|e| e && (r << e) }  # send to riemann
+    else
+      
+      #=begin
+      t = Time.now.localtime
+      #to_events.each_with_index do |e,i|
+      to_enum(:each_event).each_with_index do |e, i|
+
+        #i += 1
+        
+        puts("TICK #{t} NDX >#{i}< EVT e >#{e}<");
+
+        # COMMNETED FOR TESTINGe && (r << e)
+        
+      end  # send to riemann #TESTING
+      #=end
+    end
+  end
+
+  # This method is passed the specification and returns
+  # the consoldidated definitions collection
+  
+  def make_attributes_definitions_or_croak(attrArgs, &attrBlok)
+    eye = :'m_attrs_defs'
+
+    # Work with attribute as strings
+    
+    $DEBUG && logger_me(eye, logger_fmt_kls(:attrArgs => attrArgs, :attrBlok => attrBlok))
+
+    mustbe_attributes_specification_or_croak(attrArgs, eye, "attrArgs not attributes_specification")
+    
+    #STOPATTRARGSINSUPER
+    
+    #attrAll = mustbe_not_empty_or_croak(mustbe_array_key_or_nil_or_croak(attrArgs, :all, eye, "all attributes not array"), eye, "all attributes is empty").map(&:to_s)
+    attrAll = mustbe_not_empty_or_croak(mustbe_attributes_specification_all_key_or_croak(attrArgs, :all, eye), eye, "all attributes is empty").map(&:to_s)
+    
+
+    #puts("\n\n\nATTR ALL >#{attrAll}<")
+
+    #STOPMAKEATTRSPECSENTRY
+
+    attrInc = mustbe_attributes_specification_include_key_or_nil_or_croak(attrArgs, :include, eye) # mustbe all strings
+    #puts("ATTR INC >#{attrInc.class}< >#{attrInc}< >#{is_value_not_empty?(attrInc)}<")
+    attrInc && mustbe_not_empty_or_croak(attrInc, eye, "include attributes is empty")
+
+    attrExc = mustbe_attributes_specification_exclude_key_or_nil_or_croak(attrArgs, :exclude, eye)  || []
+    
+    attrMapNom = mustbe_attributes_definitions_key_or_nil_or_croak(attrArgs, :definitions, eye) || {}
+    attrMap = attrMapNom && potrubi_util_map_hash_kv(attrMapNom) {|k,v| [k.to_s, v]} # keys all strings
+
+    # Ensure all consistent
+    
+    attrInc && mustbe_subset_or_croak(attrInc, attrAll, eye, "include attributes contains unknown attributes")
+    mustbe_subset_or_croak(attrExc, attrAll, eye, "exclude attributes contains unknown attributes")
+    mustbe_subset_or_croak(attrMap.keys, attrAll, eye, "attribute map contains unknown attributes")
+    
+    attrUse = ((attrInc || attrAll) - attrExc).uniq  # list of unique attributes to report on
+
+    # consolidate "faked up" attr specs with ones provided to get the composite attrSpecs
+    
+    attrDefsNom = potrubi_util_array_to_hash(attrUse).merge(attrMap.select {|k,v| attrUse.include?(k)}) # consolidated "faked up" attr specs with ones provided
+
+    attrDefs = potrubi_util_map_hash_v(attrDefsNom) do | attrName, attrSpecNom|
+
+      attrSpec =
+        case attrSpecNom
+        when NilClass then {}
+        when Hash then
+          attrSpecNom.each_with_object({}) do | (verbName, verbSpec), h1 |
+          case verbName
+          when :pass_thru then h1[:pass_thru] = verbSpec  # dont touch; just pass through
+          when :event_defaults then # add these to pass_thru
+            h1[:pass_thru] = (h1[:pass_thru] || {}).merge(verbName => verbSpec)
+          when :map, :select, :metric then
+            h1[verbName] = {
+              :method_name => "#{verbName}_#{attrName}_#{rand(1000000)}", # make a unqiue name
+              :method_spec => verbSpec   # spec must be valid to dynamic_define_methods
+            }
+          else
+            logic_exception(verbName, eye, "attrName >#{attrName}<  verbName >#{verbName}< value should be impossible")
+          end
+        end
+          
+        else
+          logic_exception(attrrSpecNom, eye, "attrSpecNom value should be impossible")
+        end
+
+      attrSpec
+      
+    end
+    
+    $DEBUG && logger_mx(eye, logger_fmt_kls(:attrDefs => attrDefs))
+
+    mustbe_attributes_definitions_or_croak(attrDefs, eye, "attrDefs failed contract")
+
+    #STOPMAKEATTRSPECS
+    
+  end
+
+  def collect_attributes_method_definitions_or_croak(attrSpecs, &attrBlok)
+    eye = :'rfts col_attr_mtd_defs'
+
+    $DEBUG && logger_me(eye, logger_fmt_kls(:attrSpecs => attrSpecs, :attrBlok => attrBlok))
+
+    #STOPCOLLECTATTRSMTDS
+    
+    attrMths = attrSpecs.each_with_object({}) do | (attrName, attrSpec), h |
+
+      $DEBUG && logger_beg(eye, 'ATTR MTH', logger_fmt_kls(:attrName => attrName, :attrSpec => attrSpec))
+
+      attrSpec.select {|k,v| v.has_key?(:method_name) }.each {|k, v| h[v[:method_name]] = v[:method_spec] }
+      
+      $DEBUG && logger_fin(eye, 'ATTR MTH', logger_fmt_kls(:attrName => attrName, :attrSpec => attrSpec))
+
+    end
+    
+    
+    $DEBUG && logger_mx(eye, logger_fmt_kls(attrMths: attrMths), logger_fmt_kls(attrSpec: attrSpecs))
+
+    mustbe_hash_or_croak(attrMths, eye, "attrMths not hash")
+
+    #STOPEHERECOLATTRMTDS
+
+  end
+  
+end
+
+klassConstant = Potrubi::Core.assign_class_constant_or_croak(classContent, :Riemann, :Feeds, :Type, :Super)
+
+__END__
+

data/lib/riemann/feeds/version.rb

@@ -0,0 +1,9 @@
+
+# Version for Riemann-Feeds
+
+module Riemann
+  module Feeds
+    VERSION = "0.0.1"
+  end
+  
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: riemann-feeds
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ian Rumford
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: riemann-client
+  requirement: &20761620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *20761620
+- !ruby/object:Gem::Dependency
+  name: potrubi
+  requirement: &20760320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *20760320
+description: ! 'Riemann-Feeds: a framework for Riemann event collectors'
+email:
+- ian@rumford.name
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/riemann-feeds.rb
+- lib/riemann/feeds/feed-handler.rb
+- lib/riemann/feeds/mixin/standard.rb
+- lib/riemann/feeds/type/jmx.rb
+- lib/riemann/feeds/type/super.rb
+- lib/riemann/feeds/version.rb
+homepage: https://github.com/ianrumford/riemann-feeds
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: riemann-feeds
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: ! 'Riemann-Feeds: Riemann event collectors'
+test_files: []