marty 2.3.7 → 2.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56b3f0f54fc31cab7647f2955183a57624d2e250
-  data.tar.gz: fe7e62a123c5a0e8189076e9f5d20dd290705a26
+  metadata.gz: f0af975202886f648f8d81d92d255498764df651
+  data.tar.gz: a7fc2c052155067f86004bb661879866961b4ac5
 SHA512:
-  metadata.gz: 479aa0ed5a85663ae336e151c4c512fe92dc3da39c8fc5fa661f5307454cf6ed2b7bc0a4ad8e46698e80c32a637edb848ec245d826add0e95fbc7bc9a3e53cc0
-  data.tar.gz: c225c6156c6ca637c51a4fbd69af307d50304e0d83e43da28aca9fa4c56ecf5255318b01d4124ed165a261fb920421d53770d01f1aa69a094f9b39452c674f83
+  metadata.gz: 93a37fff530d20a6116f4e6e8425a8abfb19e4258f297fadc1fcd53b0d891e2f1cd33359b2ee8849f6ee4e44335cab33183e6bb5676d851d2a202f707f2f761e
+  data.tar.gz: 61a1cce25ce6f50d2636e638d23ac11aaa331dfa6a12380e375b6d632653018e8ab5bcc06a7510311a92df096aa940482af1eac8fd47c94dd7e8ba2d8bb6077a

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    marty (2.3.7)
+    marty (2.3.8)
       aws-sigv4 (~> 1.0, >= 1.0.2)
       axlsx (= 3.0.0pre)
       coderay

data/app/components/marty/grid.rb

@@ -174,9 +174,9 @@ class Marty::Grid < ::Netzke::Grid::Base
   end
 
   action :clear_filters do |a|
+    a.text     = "X"
     a.tooltip  = "Clear filters"
     a.handler  = :clear_filters
-    a.icon_cls = "fa fa-minus glyph"
   end
 
   # cosmetic changes

data/app/models/marty/delorean_rule.rb

@@ -56,60 +56,104 @@ class Marty::DeloreanRule < Marty::BaseRule
   def self.grid_keys(grids, eclass)
       grids.keys.map{|k| eclass.grid_final_name(k) }
   end
+
+  class ComputeError < StandardError
+    attr_reader :input, :section
+
+    def initialize(msg, stack, input, section)
+      @input = input
+      @section = section
+      super(msg)
+      set_backtrace stack
+    end
+  end
+
   def self.base_compute2(ruleh, metadata_opts, params, dgparams=params)
-    id, name, eclassname, computed_guards, grids, results, fixed_results =
-        ruleh.values_at("id", "name", "engine", "computed_guards", "grids",
-                        "results", "fixed_results")
-    eclass = eclassname && eclassname.constantize || Marty::RuleScriptSet
-    engine = eclass.new(params["pt"]).get_engine(ruleh) if
-      computed_guards.present? || results.present?
-
-    if computed_guards.present?
-      begin
-        res = engine.evaluate(eclass.node_name,
-                              compg_keys(computed_guards),
-                              params.clone)
-      rescue => e
-        raise e, "Error (guard) in rule '#{id}:#{name}': #{e}", e.backtrace
+    begin
+      id, name, eclassname, computed_guards, grids, results, fixed_results =
+          ruleh.values_at("id", "name", "engine", "computed_guards", "grids",
+                          "results", "fixed_results")
+      eclass = eclassname && eclassname.constantize || Marty::RuleScriptSet
+      engine = eclass.new(params["pt"]).get_engine(ruleh) if
+        computed_guards.present? || results.present?
+
+      result = OpenStruct.new(cg_keys: compg_keys(computed_guards))
+
+      if computed_guards.present?
+        begin
+          result.cg_vals = engine.evaluate(eclass.node_name, result.cg_keys,
+                                           params.clone)
+        rescue => e
+          result.err_message = e.message
+          result.err_stack   = e.backtrace
+          result.err_section = 'computed_guards'
+          raise ComputeError.new(
+                  "Error (guard) in rule '#{id}:#{name}': #{result.err_message}",
+                  result.err_stack,
+                  params.clone,
+                  result.err_section)
+        end
+        result.cg_hash = Hash[result.cg_keys.zip(result.cg_vals)]
+        return result.cg_hash.select{|k,v| !v} unless result.cg_vals.all?
       end
-      return Hash[compg_keys(computed_guards).zip(res).select{|k,v| !v}] unless
-        res.all?
-    end
 
-    grids_computed = false
-    grid_results = {}
-    grkeys = grid_keys(grids, eclass)
-    crkeys = comp_res_keys(results, grids, eclass, metadata_opts)
-    if (crkeys - grkeys - fixed_results.keys).present?
+      grids_computed = false
+      result.gr_keys = grid_keys(grids, eclass)
+      result.res_keys = comp_res_keys(results, grids, eclass, metadata_opts)
+      if (result.res_keys - result.gr_keys - fixed_results.keys).present?
         begin
-          eval_result = engine.evaluate(
+          result.res_vals = engine.evaluate(
             eclass.node_name,
-            crkeys,
+            result.res_keys,
             params + {
               "dgparams__" => dgparams,
             })
           grids_computed = true
         rescue => e
-          raise e, "Error (results) in rule '#{id}:#{name}': #{e}", e.backtrace
+          result.err_message = e.message
+          result.err_stack   = e.backtrace
+          result.err_section = 'results'
+          raise ComputeError.new(
+                  "Error (results) in rule '#{id}:#{name}': #{result.err_message}",
+                  result.err_stack,
+                  params + {
+                    "dgparams__" => dgparams,
+                  },
+                  result.err_section)
         end
-        result = Hash[crkeys.zip(eval_result)]
-    else
-      result = fixed_results.slice(*crkeys)
-    end
+        result.res_hash = Hash[result.res_keys.zip(result.res_vals)]
+      else
+        result.res_hash = fixed_results.slice(*result.res_keys)
+      end
 
-    if grids.present? && !grids_computed
-      pt = params['pt']
-      gres = {}
-      grid_results = grids.each_with_object({}) do |(gvar, gname), h|
-        usename = eclass.grid_final_name(gvar)
-        next h[usename] = gres[gname] if gres[gname]
-        dg = Marty::DataGrid.lookup_h(pt,gname)
-        dgr = dg && Marty::DataGrid.lookup_grid_distinct_entry_h(pt, dgparams,
-                                                                 dg)
-        h[usename] = gres[gname] = dgr["result"] if dgr
+      if grids.present? && !grids_computed
+        pt = params['pt']
+        gres = {}
+        result.gr_hash = grids.each_with_object({}) do |(gvar, gname), h|
+          usename = eclass.grid_final_name(gvar)
+          next h[usename] = gres[gname] if gres[gname]
+          dg = Marty::DataGrid.lookup_h(pt,gname)
+          dgr = dg && Marty::DataGrid.lookup_grid_distinct_entry_h(pt, dgparams,
+                                                                   dg)
+          h[usename] = gres[gname] = dgr["result"] if dgr
+        end
       end
+      (result.res_hash||{}) + (result.gr_hash||{})
+    ensure
+      resh = result.to_h
+      [:res_keys, :res_vals].each {|k|resh.delete(k)} if
+        result.res_hash.present? || result.res_keys.blank?
+      [:cg_keys, :cg_vals].each {|k|resh.delete(k)} if
+        result.cg_hash.present? ||  result.cg_keys.blank?
+      resh.delete(:gr_keys) if result.gr_hash.present? || result.gr_keys.blank?
+      estack_full = resh.delete(:err_stack)
+      estack = estack_full && {
+        err_stack: estack_full.select{ |l| l.starts_with?('DELOREAN')}} || {}
+      Marty::Logger.info("Rule Log #{ruleh['name']}",
+                         { input: params,
+                           dgparams: dgparams } + resh + estack
+                        ) if ruleh['fixed_results']['log__']
     end
-    result + grid_results
   end
   def self.base_compute(ruleh, params, dgparams=params)
     base_compute2(ruleh, nil, params, dgparams)

data/lib/marty/logger.rb

@@ -1,4 +1,5 @@
 class Marty::Logger
+  include Delorean::Model
 
   def self.method_missing(m, *args, &block)
     return super unless
@@ -20,4 +21,10 @@ class Marty::Logger
       raise "#{error_message}: #{e.message}"
     end
   end
+
+  delorean_fn :dllog, sig: [2, 20] do
+     |*args|
+
+     info args[0], args[1..-1]
+  end
 end

data/lib/marty/version.rb

@@ -1,3 +1,3 @@
 module Marty
-  VERSION = "2.3.7"
+  VERSION = "2.3.8"
 end

data/spec/features/rule_spec.rb

@@ -358,18 +358,18 @@ EOL
             "bv"=>"base_value"}}
 
     expect(r.first.as_json).to include(exp)
-    expect(xrv.col_values(:g_string, 5, 0)).to eq(["aaa", "bbb", "ccc",
-                                                   "ddd", "eee"])
+    expect(xrv.col_values(:g_string, 8, 0)).to eq(["aaa", "bbb", "ccc", "ddd",
+                                                   "eee", "eee", "eee", "eee"])
     click_column(xrv, "String list Guard")
-    expect(xrv.col_values(:g_string, 5, 0)).to eq(["eee", "ddd", "ccc",
-                                                   "bbb", "aaa"])
+    expect(xrv.col_values(:g_string, 8, 0)).to eq(["eee", "eee", "eee", "eee",
+                                                   "ddd", "ccc", "bbb", "aaa"])
     column_filter(xrv, "String list Guard", "eee")
     rc = xrv.row_count
-    expect(xrv.col_values(:g_string,rc,0)).to eq(["eee"])
+    expect(xrv.col_values(:g_string,rc,0)).to eq(["eee", "eee", "eee", "eee"])
     column_filter_toggle(xrv, "String list Guard")
     rc = xrv.row_count
-    expect(xrv.col_values(:g_string,rc,0)).to eq(["eee", "ddd", "ccc",
-                                                   "bbb", "aaa"])
+    expect(xrv.col_values(:g_string,rc,0)).to eq(["eee", "eee", "eee", "eee",
+                                                  "ddd", "ccc", "bbb", "aaa"])
     column_filter(xrv, "Grids", "Grid1")
     rc = xrv.row_count
                                          # netzke reports jsonb as string
@@ -378,6 +378,9 @@ EOL
     column_filter_toggle(xrv, "Grids")
     rc = xrv.row_count
     expect(xrv.col_values(:grids,rc,0)).to eq([%Q({"grid1":"DataGrid3"}),
+                                               %Q({"grid1":"DataGrid3"}),
+                                               %Q({"grid1":"DataGrid3"}),
+                                               %Q({"grid1":"DataGrid3"}),
                                                %Q({"grid1":"DataGrid3"}),
                                                %Q({"grid1":"DataGrid2"}),
                                                %Q({"grid1":"DataGrid1"}),

data/spec/fixtures/csv/rule/XyzRule.csv

@@ -4,3 +4,24 @@ ZRule2,ZRule,2017-2-1 09:01:00,"{""g_string"":""bbb"",""g_range1"":""[20,30)"","
 ZRule3,ZRule,2017-3-1 10:00:00,"{""g_string"":""ccc"",""g_range1"":""[30,40)"",""g_integer"":3,""g_date"":""2017-1-3"",""g_datetime"":""2017-1-1 12:00:03""}","{}","{""grid1"":""DataGrid2""}","{""bvlen"": ""base_value.length"", ""bv"":""base_value""}"
 ZRule4,ZRule,2017-3-1 11:00:00,"{""g_string"":""ddd"",""g_range1"":""[40,50)"",""g_integer"":2,""g_date"":""2017-1-4"",""g_datetime"":""2017-1-1 12:00:04""}","{}","{""grid1"":""DataGrid3""}","{""bvlength"": ""base_value.length"", ""bv"":""base_value""}"
 ZRule5,ZRule,2017-3-1 11:00:01,"{""g_string"":""eee"",""g_range1"":""[50,60)"",""g_integer"":1,""g_date"":""2017-1-5"",""g_datetime"":""2017-1-1 12:00:05""}","{}","{""grid1"":""DataGrid3""}","{""bvlen"": ""base_value.length"", ""bv"":""base_value""}"
+ZRule6,ZRule,2017-3-1 11:00:01,"{""g_string"":""eee"",""g_range1"":""[50,60)"",""g_integer"":6,""g_date"":""2017-1-5"",""g_datetime"":""2017-1-1 12:00:05""}","{}","{""grid1"":""DataGrid3""}","{
+""log__"":""true"",
+""tmp_var1"":""base_value.length*2"",
+""tmp_var2"":""tmp_var1*2"",
+""tmp_var3"":""tmp_var2*2"",
+""tmp_var4"":""\""a string\"" * tmp_var1"",
+""bvlen"": ""base_value.length"", ""bv"":""tmp_var4""}"
+ZRule7,ZRule,2017-3-1 11:00:01,"{""g_string"":""eee"",""g_range1"":""[50,60)"",""g_integer"":7,""g_date"":""2017-1-5"",""g_datetime"":""2017-1-1 12:00:05""}","{
+""some_guard"":""true""}","{
+""grid1"":""DataGrid3""}","{
+""log__"":""true"",
+""tmp_var1"":""base_value.length*2"",
+""tmp_var2"":""tmp_var1*2"",
+""tmp_var3"":""tmp_var2*2"",
+""tmp_var4"":""\""a string\"" + tmp_var1"",
+""bvlen"": ""tmp_var4"", ""bv"":""tmp_var4""}"
+ZRule8,ZRule,2017-3-1 11:00:01,"{""g_string"":""eee"",""g_range1"":""[50,60)"",""g_integer"":8,""g_date"":""2017-1-5"",""g_datetime"":""2017-1-1 12:00:05""}","{
+""cg1"":""1/0""
+}","{""grid1"":""DataGrid3""}","{
+""log__"":""true"",
+""bvlen"": ""1"", ""bv"":""2""}"

data/spec/models/rule_spec.rb

@@ -266,7 +266,7 @@ module Marty::RuleSpec
       let(:complex) { Gemini::MyRule.get_matches('infinity',
                                             {'rule_type'=>'ComplexRule'},
                                             {'g_string'=>'def'}).first }
-      let(:xyz) { Gemini::XyzRule.get_matches('infinity',
+          let(:xyz) { Gemini::XyzRule.get_matches('infinity',
                                               {'rule_type'=>'ZRule'},
                                               {'g_integer'=> 2}).first }
       let(:simple) {
@@ -352,6 +352,98 @@ module Marty::RuleSpec
                                    'param2' => 1})
         expect(v["final_value"]).to eq(15)
       end
+      it "exceptions/logging" do
+        r6, r7, r8 = [6, 7, 8].map do |i|
+          Gemini::XyzRule.get_matches('infinity',
+                                      {'rule_type'=>'ZRule'},
+                                      {'g_integer'=>i}).first
+        end
+        pt = Time.zone.now+1
+        input = {"pt"=>pt,
+                 "p1"=>12,
+                 "p2"=>3,
+                 "flavor"=>"cherry"}
+        v1 = r6.compute(input)
+        begin
+          v2 = r7.compute(input)
+        rescue Marty::DeloreanRule::ComputeError => e
+          exp = 'no implicit conversion of Fixnum into String'
+          expect(e.message).to include(exp)
+          expres = [/DELOREAN__XyzRule_\d+_1483228800.0:23:in .+'/,
+                 /DELOREAN__XyzRule_\d+_1483228800.0:23:in .tmp_var4__D'/,
+                 /DELOREAN__XyzRule_\d+_1483228800.0:27:in .bv__D'/]
+          expres.each_with_index do |expre, i|
+            expect(e.backtrace[i]).to match(expre)
+          end
+          expect(e.input).to eq(input + {'dgparams__'=>input})
+          expect(e.section).to eq('results')
+        end
+        begin
+          v2 = r8.compute(input)
+        rescue Marty::DeloreanRule::ComputeError => e
+          exp = 'divided by 0'
+          expect(e.message).to include(exp)
+          expres = [%r(DELOREAN__XyzRule_\d+_1483228800.0:5:in ./'),
+                 /DELOREAN__XyzRule_\d+_1483228800.0:5:in .cg1__D'/]
+          expres.each_with_index do |expre, i|
+            expect(e.backtrace[i]).to match(expre)
+          end
+          expect(e.input).to eq(input)
+          expect(e.section).to eq('computed_guards')
+        end
+        log_ents = Marty::Log.all
+        expect(log_ents.map{|le|le.message}).to eq(['Rule Log ZRule6',
+                                                   'Rule Log ZRule7',
+                                                   'Rule Log ZRule8'])
+        ptjson = pt.as_json
+        exp = {"input"=>{"p1"=>12, "p2"=>3,
+                         "pt"=>ptjson,
+                         "flavor"=>"cherry"},
+               "dgparams"=>{"p1"=>12, "p2"=>3,
+                            "pt"=>ptjson,
+                            "flavor"=>"cherry"},
+               "gr_keys"=>["grid1_grid_result"],
+               "res_hash"=>
+               {"bv"=>"a stringa stringa stringa stringa stringa stringa stringa "\
+                "stringa stringa stringa stringa stringa stringa stringa "\
+                "stringa stringa stringa stringa stringa stringa stringa "\
+                "stringa stringa stringa stringa string",
+                "grid1_grid_result"=>19}}
+        expect(log_ents[0].details).to eq(exp)
+        exp = {"input"=>{"p1"=>12, "p2"=>3,
+                         "pt"=>ptjson,
+                         "flavor"=>"cherry"},
+               "cg_hash"=>{"some_guard"=>true},
+               "gr_keys"=>["grid1_grid_result"],
+               "dgparams"=>{"p1"=>12, "p2"=>3,
+                            "pt"=>ptjson,
+                            "flavor"=>"cherry"},
+               "res_keys"=>["bv", "grid1_grid_result"],
+               "err_section"=>"results",
+               "err_message"=>"no implicit conversion of Fixnum into String"}
+        expect(log_ents[1].details.except('err_stack')).to eq(exp)
+        expres = [/DELOREAN__XyzRule_\d+_1483228800.0:23:in .+'/,
+               /DELOREAN__XyzRule_\d+_1483228800.0:23:in .tmp_var4__D'/,
+               /DELOREAN__XyzRule_\d+_1483228800.0:27:in .bv__D'/]
+        expres.each_with_index do |expre, i|
+          expect(log_ents[1].details['err_stack'][i]).to match(expre)
+        end
+        exp = {"input"=>{"p1"=>12, "p2"=>3,
+                         "pt"=>ptjson,
+                         "flavor"=>"cherry"},
+               "cg_keys"=>["cg1"],
+               "dgparams"=>{"p1"=>12, "p2"=>3,
+                            "pt"=>ptjson,
+                            "flavor"=>"cherry"},
+               "err_section"=>"computed_guards",
+               "err_message"=>"divided by 0"}
+        expect(log_ents[2].details.except('err_stack')).to eq(exp)
+        expres = [%r(DELOREAN__XyzRule_\d+_1483228800.0:5:in ./'),
+               /DELOREAN__XyzRule_\d+_1483228800.0:5:in .cg1__D'/]
+        expres.each_with_index do |expre, i|
+          expect(log_ents[2].details['err_stack'][i]).to match(expre)
+        end
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marty
 version: !ruby/object:Gem::Version
-  version: 2.3.7
+  version: 2.3.8
 platform: ruby
 authors:
 - Arman Bostani
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-14 00:00:00.000000000 Z
+date: 2018-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg