kennel 1.85.0 → 1.87.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a269f904837e3451d2476a99ebcd9d456dc91ae0f1a90736ca92b76a9e92bee9
-  data.tar.gz: 53b4d080603c79ec8e70dfe2e95cbfcb4fa2325f1e9fa803a5c8bbcafc9db646
+  metadata.gz: 42e4d1fd80bfa23ccbed32dcc6cfeb05fda2a2748bc29b302e6f982273302551
+  data.tar.gz: 6ffc6ddafa5518868cc913fd05add8f11eb49729ba4ca498b357241ab80111f3
 SHA512:
-  metadata.gz: 447b71298164f342b2e7cd707c1deaa12dfd260845c12125f8f9bc31849c13bb0d8c863613ed5b3b295009d5be4c28e351ea4c91b6eb3377a75d8140c25bf311
-  data.tar.gz: 988960502b6480687915669d317f920bc8af88e7926191a78cca3b7d55493b63e981bd5d880d137e3307a56ef1cdea23c18ad1139126e6f6310951100447422a
+  metadata.gz: 76f2b875dd8e918db62b0ee13a6ad01acd6a187f11127824176cdee2f8665ec0ffa4d5ad3a0f8fbfd97fbf980faae8039cdbca8f2b078ef81e091a9a34c3ed0e
+  data.tar.gz: a612a2d02f684f847ef6c167d2a3ef9fc815f80c1fd618106c8824017cede188c77dec3700d1a7afd46c481cd3c8fa7c37358af6a9737c1703a68491d159a5b1

data/lib/kennel/importer.rb

@@ -60,10 +60,16 @@ module Kennel
           query.sub!(/([><=]) (#{Regexp.escape(critical.to_f.to_s)}|#{Regexp.escape(critical.to_i.to_s)})$/, "\\1 \#{critical}")
         end
 
+        # using float in query is not allowed, so convert here
+        data[:critical] = data[:critical].to_i if data[:type] == "event alert"
+
         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,14 +12,61 @@ 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
 
       DEFAULTS = {
-        template_variable_presets: nil,
-        reflow_type: "auto"
+        template_variable_presets: nil
       }.freeze
 
       settings :title, :description, :definitions, :widgets, :layout_type, :template_variable_presets, :reflow_type
@@ -29,7 +76,7 @@ module Kennel
         definitions: -> { [] },
         widgets: -> { [] },
         template_variable_presets: -> { DEFAULTS.fetch(:template_variable_presets) },
-        reflow_type: -> { DEFAULTS.fetch(:reflow_type) },
+        reflow_type: -> { layout_type == "ordered" ? "auto" : nil },
         id: -> { nil }
       )
 
@@ -41,52 +88,43 @@ module Kennel
         def normalize(expected, actual)
           super
 
-          ignore_default(expected, actual, DEFAULTS)
+          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
 
@@ -112,12 +150,13 @@ module Kennel
           layout_type: layout_type,
           title: "#{title}#{LOCK}",
           description: description,
-          reflow_type: reflow_type,
           template_variables: render_template_variables,
           template_variable_presets: template_variable_presets,
           widgets: all_widgets
         }
 
+        @json[:reflow_type] = reflow_type if reflow_type # setting nil breaks create with "ordered"
+
         @json[:id] = id if id
 
         validate_json(@json) if validate

data/lib/kennel/models/slo.rb

@@ -63,7 +63,7 @@ module Kennel
       end
 
       def self.parse_url(url)
-        url[/\/slo\?.*slo_id=([a-z\d]+)/, 1]
+        url[/\/slo(\?.*slo_id=|\/edit\/)([a-z\d]{10,})/, 2]
       end
 
       def resolve_linked_tracking_ids!(id_map, **args)

data/lib/kennel/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kennel
 version: !ruby/object:Gem::Version
-  version: 1.85.0
+  version: 1.87.1
 platform: ruby
 authors:
 - Michael Grosser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-24 00:00:00.000000000 Z
+date: 2021-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -94,14 +94,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.3
+rubygems_version: 3.2.16
 signing_key: 
 specification_version: 4
 summary: Keep datadog monitors/dashboards/etc in version control, avoid chaotic management