kennel 1.86.1 → 1.87.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2531f5f8a3ef6c978e2aeeec1db0a16f56aebe690ef6eae8baefff34c3c53fe
-  data.tar.gz: d650a926e7d730f34e3dc90833f04f693161ad6aa112fd8ffdbca88f37d37497
+  metadata.gz: 42e4d1fd80bfa23ccbed32dcc6cfeb05fda2a2748bc29b302e6f982273302551
+  data.tar.gz: 6ffc6ddafa5518868cc913fd05add8f11eb49729ba4ca498b357241ab80111f3
 SHA512:
-  metadata.gz: 12c01b65de8be29754e78b8caa6d8d8cc3f8c8089928008917a31121d3641161eb8b519aedfd7f5a643ff9f4f1123579e8bc6e07382e26613b5dd9937f6f6c16
-  data.tar.gz: 421e6d81e4ea91f0eb152ba5230026334221e452f5dea8a4e040d5b8285db8f0913443357b128f5c00e917557ace751f264a55568e50ee86a8e304fb1f9f188e
+  metadata.gz: 76f2b875dd8e918db62b0ee13a6ad01acd6a187f11127824176cdee2f8665ec0ffa4d5ad3a0f8fbfd97fbf980faae8039cdbca8f2b078ef81e091a9a34c3ed0e
+  data.tar.gz: a612a2d02f684f847ef6c167d2a3ef9fc815f80c1fd618106c8824017cede188c77dec3700d1a7afd46c481cd3c8fa7c37358af6a9737c1703a68491d159a5b1

data/lib/kennel/importer.rb

@@ -66,7 +66,10 @@ module Kennel
         data[:type] = "query alert" if data[:type] == "metric alert"
       when "dashboard"
         widgets = data[:widgets]&.flat_map { |widget| widget.dig(:definition, :widgets) || [widget] }
-        widgets&.each { |widget| dry_up_query!(widget) }
+        widgets&.each do |widget|
+          dry_up_query!(widget)
+          (widget.dig(:definition, :markers) || []).each { |m| m[:label]&.delete! " " }
+        end
       end
 
       data.delete(:tags) if data[:tags] == [] # do not create super + [] call

data/lib/kennel/models/dashboard.rb

@@ -12,8 +12,56 @@ module Kennel
         style: { line_width: "normal", palette: "dog_classic", line_type: "solid" }
       }.freeze
       WIDGET_DEFAULTS = {
-        "timeseries" => { show_legend: false, legend_size: "0" },
-        "note" => { background_color: "white", font_size: "14", show_tick: false, tick_edge: "left", tick_pos: "50%", text_align: "left" }
+        "timeseries" => {
+          legend_size: "0",
+          markers: [],
+          legend_columns: [
+            "avg",
+            "min",
+            "max",
+            "value",
+            "sum"
+          ],
+          legend_layout: "auto",
+          yaxis: {
+            include_zero: true,
+            label: "",
+            scale: "linear",
+            min: "auto",
+            max: "auto"
+          },
+          show_legend: true,
+          time: {},
+          title_align: "left",
+          title_size: "16"
+        },
+        "note" => {
+          show_tick: false,
+          tick_edge: "left",
+          tick_pos: "50%",
+          text_align: "left",
+          has_padding: true,
+          background_color: "white",
+          font_size: "14"
+        },
+        "query_value" => {
+          autoscale: true,
+          time: {},
+          title_align: "left",
+          title_size: "16"
+        },
+        "free_text" => {
+          font_size: "auto"
+        },
+        "check_status" => {
+          title_align: "left",
+          title_size: "16"
+        },
+        "slo" => {
+          global_time_target: "0",
+          title_align: "left",
+          title_size: "16"
+        }
       }.freeze
       SUPPORTED_DEFINITION_OPTIONS = [:events, :markers, :precision].freeze
 
@@ -40,53 +88,43 @@ module Kennel
         def normalize(expected, actual)
           super
 
-          ignore_default(expected, actual, DEFAULTS)
-          ignore_default(expected, actual, reflow_type: "auto") if expected[:layout_type] == "ordered"
+          ignore_default expected, actual, DEFAULTS
+          ignore_default expected, actual, reflow_type: "auto" if expected[:layout_type] == "ordered"
 
           widgets_pairs(expected, actual).each do |pair|
-            # conditional_formats ordering is randomly changed by datadog, compare a stable ordering
-            pair.each do |widgets|
-              widgets.each do |widget|
-                if formats = widget.dig(:definition, :conditional_formats)
-                  widget[:definition][:conditional_formats] = formats.sort_by(&:hash)
-                end
-              end
-            end
-
-            ignore_widget_defaults pair
-
+            pair.each { |w| sort_conditional_formats w }
+            ignore_widget_defaults(*pair)
             ignore_request_defaults(*pair)
-
-            # ids are kinda random so we always discard them
-            pair.each { |widgets| widgets.each { |w| w.delete(:id) } }
+            pair.each { |widget| widget&.delete(:id) } # ids are kinda random so we always discard them
           end
         end
 
         private
 
-        def ignore_widget_defaults(pair)
-          pair.map(&:size).max.times do |i|
-            types = pair.map { |w| w.dig(i, :definition, :type) }.uniq
-            next unless types.size == 1
-            next unless defaults = WIDGET_DEFAULTS[types.first]
-            ignore_defaults(pair[0], pair[1], defaults, nesting: :definition)
+        # conditional_formats ordering is randomly changed by datadog, compare a stable ordering
+        def sort_conditional_formats(widget)
+          if formats = widget&.dig(:definition, :conditional_formats)
+            widget[:definition][:conditional_formats] = formats.sort_by(&:hash)
           end
         end
 
+        def ignore_widget_defaults(expected, actual)
+          types = [expected&.dig(:definition, :type), actual&.dig(:definition, :type)].uniq.compact
+          return unless types.size == 1
+          return unless defaults = WIDGET_DEFAULTS[types.first]
+          ignore_default expected&.[](:definition) || {}, actual&.[](:definition) || {}, defaults
+        end
+
         # discard styles/conditional_formats/aggregator if nothing would change when we applied (both are default or nil)
         def ignore_request_defaults(expected, actual)
-          [expected.size, actual.size].max.times do |i|
-            a_r = actual.dig(i, :definition, :requests) || []
-            e_r = expected.dig(i, :definition, :requests) || []
-            ignore_defaults e_r, a_r, REQUEST_DEFAULTS
-          end
+          a_r = actual&.dig(:definition, :requests) || []
+          e_r = expected&.dig(:definition, :requests) || []
+          ignore_defaults e_r, a_r, REQUEST_DEFAULTS
         end
 
-        def ignore_defaults(expected, actual, defaults, nesting: nil)
+        def ignore_defaults(expected, actual, defaults)
           [expected.size, actual.size].max.times do |i|
-            e = expected.dig(i, *nesting) || {}
-            a = actual.dig(i, *nesting) || {}
-            ignore_default(e, a, defaults)
+            ignore_default expected[i] || {}, actual[i] || {}, defaults
           end
         end
 
@@ -99,7 +137,7 @@ module Kennel
             nested = pair.map { |d| d.dig(:widgets, i, :definition, :widgets) || [] }
             result << nested if nested.any?(&:any?)
           end
-          result
+          result.flat_map { |a, e| [a.size, e.size].max.times.map { |i| [a[i], e[i]] } }
         end
       end
 

data/lib/kennel/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Kennel
-  VERSION = "1.86.1"
+  VERSION = "1.87.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kennel
 version: !ruby/object:Gem::Version
-  version: 1.86.1
+  version: 1.87.1
 platform: ruby
 authors:
 - Michael Grosser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-21 00:00:00.000000000 Z
+date: 2021-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday