zabbix_manager 5.1.6 → 6.0.0

data/lib/zabbix_manager/monitoring/line_items.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+class ZabbixManager
+  class Monitoring
+    # 解析端点的数值监控项，并复用主机已有的共享 ICMP 检查。
+    # 不重命名、启用、删除或接管已有 ICMP 监控项。
+    # @api private
+    class LineItems
+      PATTERNS = {
+        speed: /net\.if\.speed|ifhighspeed|interface speed|接口速率|1\.3\.6\.1\.2\.1\.31\.1\.1\.1\.15\./i,
+        status: /net\.if\.(?:status|oper)|ifoperstatus|operational status|接口状态|1\.3\.6\.1\.2\.1\.2\.2\.1\.8\./i
+      }.freeze
+
+      def initialize(items)
+        @items = items
+      end
+
+      # 两个流量方向必须唯一、不同且属于目标主机；附加指标只在选择器启用时解析。
+      # @return [Hash{Symbol => Hash}] 流量及可选状态/速率监控项
+      # @raise [Invalid, Conflict, ProtocolError] 量纲、身份、归属或响应结构无法确认
+      def resolve(line, candidates, hostid:)
+        unless candidates.is_a?(Array) && candidates.all? { |item| item.is_a?(Hash) }
+          raise ProtocolError, "item.get must return an array of item objects"
+        end
+
+        selected = TrafficItems.new(candidates).for_interface(line.interface_name)
+        %i[status speed].each do |kind|
+          selector = line.public_send(kind)
+          next unless selector
+
+          matches = candidates.select do |item|
+            if selector.is_a?(Hash)
+              item["itemid"].to_s == selector[:itemid].to_s
+            else
+              TrafficItems.interface_matches?(item, line.interface_name) &&
+                [item["key_"], item["name"], item["snmp_oid"]].join(" ").match?(PATTERNS.fetch(kind))
+            end
+          end
+          raise Conflict,
+                "expected one #{kind} item for #{line.interface_name}, found #{matches.length}" unless matches.one?
+
+          selected[kind] = matches.first.deep_symbolize_keys
+        end
+        selected.each do |kind, item|
+          validate_numeric!(item, kind)
+          raise ProtocolError, "#{kind} item belongs to another host" unless item[:hostid].to_s == hostid.to_s
+        end
+        unless selected.values.map { |item| item[:itemid].to_s }.uniq.length == selected.length
+          raise Conflict, "line metrics must refer to distinct items"
+        end
+
+        selected
+      end
+
+      # 查询稳定 ICMP key 并生成候选属性；缺失对象在执行阶段才创建。
+      # @return [Hash] attributes 及已有 itemid（不存在时为 nil）
+      def icmp_plan(hostid, target)
+        attributes = {
+          hostid: hostid, name: "ICMP #{target}", key_: "icmpping[#{target}]", type: 3,
+          value_type: 3, delay: "1m", history: "30d", trends: "365d", status: 0
+        }
+        current = find_icmp(attributes)
+        { attributes: attributes, itemid: current&.fetch(:itemid) }
+      end
+
+      # 在调用方工作流互斥锁内再次查询，不覆盖已有共享监控项。
+      def ensure_icmp(plan)
+        current = find_icmp(plan.fetch(:attributes))
+        return current.fetch(:itemid).to_i if current
+
+        @items.create(plan.fetch(:attributes))
+      end
+
+      private
+
+      def find_icmp(attributes)
+        matches = @items.for_host(attributes[:hostid], keys: attributes[:key_])
+        unless matches.is_a?(Array) && matches.all? { |item| item.is_a?(Hash) }
+          raise ProtocolError, "item.get must return an array of item objects"
+        end
+        raise Conflict, "multiple items use ICMP key #{attributes[:key_]}" if matches.length > 1
+        return if matches.empty?
+
+        item = matches.first.deep_symbolize_keys
+        unless item[:hostid].to_s == attributes[:hostid].to_s && item[:key_] == attributes[:key_]
+          raise ProtocolError, "item.get returned an ICMP item outside the requested host and key"
+        end
+
+        validate_numeric!(item, :reachability)
+        unless item[:type].to_s == "3" && item[:value_type].to_s == "3"
+          raise Conflict, "existing ICMP item must be an unsigned simple check"
+        end
+
+        item
+      end
+
+      def validate_numeric!(item, kind)
+        Validation.positive_id!(item[:itemid], "#{kind} itemid")
+        Validation.item_key!(item[:key_])
+        unless %w[0 3].include?(item[:value_type].to_s)
+          raise Invalid, "#{kind} item must have a numeric value_type"
+        end
+        raise Conflict, "#{kind} item must be enabled" unless item[:status].to_s == "0"
+        return unless kind == :status && item[:value_type].to_s != "3"
+
+        raise Invalid, "status item must use unsigned integer values with 1 meaning up"
+      end
+    end
+  end
+end

data/lib/zabbix_manager/monitoring/line_lifecycle.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+class ZabbixManager
+  class Monitoring
+    # 通过原生 API 核对端点触发器归属、停用旧检查并读取问题。
+    # 不保存持久状态；以已确认的标签和 ID 界定管理范围。
+    # @api private
+    class LineLifecycle
+      KINDS = %i[interface_status bandwidth low_traffic reachability].freeze
+
+      def initialize(manager, hostid, line_id)
+        Validation.positive_id!(hostid, "hostid")
+        unless line_id.is_a?(String) || line_id.is_a?(Integer)
+          raise Invalid, "line_id must be a string or integer"
+        end
+
+        @line_id = Validation.text!(line_id.to_s, "line_id")
+        @prefix = "interface:#{@line_id}:"
+        @keys = KINDS.map { |kind| "#{@prefix}#{kind}" }
+        if @keys.any? { |key| key.length > Triggers::MAX_MANAGED_KEY_LENGTH }
+          raise Invalid, "managed_key is too long"
+        end
+
+        @manager, @hostid = manager, hostid
+      end
+
+      # 服务端前缀过滤后，再以完整受管键筛选并拒绝重复身份。
+      # @return [Array<Hash>] 该端点已知类型的原生触发器；所有者由 owned 继续筛选
+      def inventory
+        records = @manager.client.api_request(
+          method: "trigger.get",
+          params: {
+            hostids: @hostid, tags: [{ tag: "zabbix_manager_id", value: @prefix, operator: 0 }],
+            output: "extend", selectTags: "extend", selectItems: ["itemid", "name"], expandExpression: true
+          }
+        )
+        unless records.is_a?(Array) && records.all? { |record| record.is_a?(Hash) }
+          raise ProtocolError, "trigger.get must return an array of trigger objects"
+        end
+
+        records.each do |record|
+          tags = record["tags"]
+          valid_tags = tags.is_a?(Array) && tags.all? do |tag|
+            tag.is_a?(Hash) && tag["tag"].is_a?(String) && tag["value"].is_a?(String)
+          end
+          raise ProtocolError, "trigger.get must include valid tags for ownership verification" unless valid_tags
+        end
+        selected = records.select { |record| managed_key(record) }
+        selected.each { |record| validate_receipt!(record) }
+        ids = selected.map { |record| record["triggerid"].to_s }
+        raise ProtocolError, "trigger.get returned duplicate trigger IDs" unless ids.uniq == ids
+
+        identities = selected.map { |record| managed_key(record) }
+        raise Conflict, "multiple triggers use the same line managed key" unless identities.uniq == identities
+
+        selected
+      end
+
+      # 兼容缺少 line_id 的既有受管标签，但拒绝其他管理方或矛盾的端点标签。
+      # @return [Array<Hash>] 当前库拥有的触发器
+      def owned(records = inventory)
+        records.select do |record|
+          owner = tag_values(record, "managed_by")
+          ids = tag_values(record, "line_id")
+          owner == ["zabbix_manager"] && (ids.empty? || ids == [@line_id])
+        end
+      end
+
+      def validate_ownership!(records, desired_keys)
+        foreign = records - owned(records)
+        if foreign.any? { |record| desired_keys.include?(managed_key(record)) }
+          raise Conflict, "line managed key belongs to another owner"
+        end
+      end
+
+      def disable(records = owned)
+        return [] if records.empty?
+
+        @manager.triggers.set_status(hostid: @hostid, triggerids: records.map { |record| record.fetch("triggerid") },
+                                     enabled: false)
+      end
+
+      # 仅停用本轮期望之外的受管类型；调用方必须先确认所有期望触发器写入成功。
+      # @return [Array<Integer>] 已确认停用的 ID；不删除对象
+      def retire(records, desired_keys)
+        disable(owned(records).reject { |record| desired_keys.include?(managed_key(record)) })
+      end
+
+      def problems(time_from:, time_till:, limit:)
+        from = timestamp(time_from, "time_from")
+        till = timestamp(time_till, "time_till")
+        raise Invalid, "time_from must not be after time_till" if from > till
+        unless limit.is_a?(Integer) && limit.between?(1, 1000)
+          raise Invalid, "limit must be an integer between 1 and 1000"
+        end
+
+        ids = owned.map { |record| record.fetch("triggerid").to_s }
+        records = if ids.empty?
+                    []
+                  else
+                    @manager.client.api_request(
+                      method: "problem.get",
+                      params: {
+                        hostids: @hostid, objectids: ids, source: 0, object: 0, recent: true,
+                        time_from: from, time_till: till, output: "extend", selectTags: "extend",
+                        sortfield: "eventid", sortorder: "DESC", limit: limit + 1
+                      }
+                    )
+                  end
+        unless records.is_a?(Array) && records.all? { |record| record.is_a?(Hash) }
+          raise ProtocolError, "problem.get must return an array of problem objects"
+        end
+        unless records.all? { |record| ids.include?(record["objectid"].to_s) }
+          raise ProtocolError, "problem.get returned a trigger outside the requested line"
+        end
+        raise ProtocolError, "problem.get exceeded the requested limit" if records.length > limit + 1
+
+        validate_problems!(records, from, till)
+
+        { problems: records.first(limit), truncated: records.length > limit, time_from: from, time_till: till,
+          limit: limit }
+      end
+
+      private
+
+      def tag_values(record, name)
+        Array(record["tags"]).filter_map do |tag|
+          tag["value"] if tag.is_a?(Hash) && tag["tag"] == name
+        end.uniq
+      end
+
+      def managed_key(record)
+        values = tag_values(record, "zabbix_manager_id")
+        matches = values & @keys
+        raise Conflict, "trigger has multiple line managed keys" if matches.any? && values.length > 1
+
+        matches.first
+      end
+
+      def validate_receipt!(record)
+        Validation.positive_id!(record["triggerid"], "triggerid")
+      rescue Invalid => error
+        raise ProtocolError, error.message
+      end
+
+      def timestamp(value, name)
+        value = value.to_i if value.is_a?(Time)
+        raise Invalid, "#{name} must be a non-negative Integer or Time" unless value.is_a?(Integer) && value >= 0
+
+        value
+      end
+
+      def validate_problems!(records, from, till)
+        records.each do |record|
+          Validation.positive_id!(record["eventid"], "eventid")
+          clock = record["clock"]
+          unless (clock.is_a?(Integer) || clock.is_a?(String)) && clock.to_s.match?(/\A\d+\z/) &&
+                 clock.to_i.between?(from, till)
+            raise ProtocolError, "problem.get returned an invalid or out-of-range clock"
+          end
+        end
+        ids = records.map { |record| record["eventid"].to_s }
+        raise ProtocolError, "problem.get returned duplicate event IDs" unless ids.uniq == ids
+      rescue Invalid => error
+        raise ProtocolError, error.message
+      end
+    end
+  end
+end

data/lib/zabbix_manager/monitoring/line_plan.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+class ZabbixManager
+  class Monitoring
+    # 统一生成触发器属性，供预览和实际执行复用。
+    # 状态触发器 ID 确认之前，依赖以指标类型名称表示。
+    # @api private
+    class LinePlan
+      def initialize(client, line, host, items, icmp_item)
+        @client, @line, @host, @items, @icmp_item = client, line, host, items, icmp_item
+        @expressions = Expressions.new(client, host[:host])
+        @line_id = line.resolved_id(host[:hostid])
+        validate_metadata_version!
+      end
+
+      # 纯本地构造计划，不写远端；依赖保留为指标名称，执行时转换为已确认 triggerid。
+      # @return [Hash] 端点身份、监控项 ID、触发器属性及依赖计划
+      def to_h
+        triggers = {}
+        triggers[:interface_status] = status_trigger if @items[:status]
+        triggers[:bandwidth] = bandwidth_trigger
+        triggers[:low_traffic] = low_trigger if @line.low_traffic
+        triggers[:reachability] = reachability_trigger if @icmp_item
+        dependencies = triggers.keys.to_h do |kind|
+          [kind, @items[:status] && kind != :interface_status ? [:interface_status] : []]
+        end
+        itemids = @items.transform_values { |item| item.fetch(:itemid).to_i }
+        itemids[:reachability] = @icmp_item[:itemid].to_i if @icmp_item&.dig(:itemid)
+        {
+          hostid: @host[:hostid].to_i, host: @host[:host], interface: @line.interface_name, line_id: @line_id,
+          itemids: itemids, triggers: triggers, dependencies: dependencies, icmp_item: @icmp_item
+        }
+      end
+
+      private
+
+      def validate_metadata_version!
+        { opdata: "4.4", event_name: "5.2" }.each do |field, minimum|
+          next unless @line.metadata.key?(field) && @expressions.version < Gem::Version.new(minimum)
+
+          raise Invalid, "#{field} requires Zabbix #{minimum} or newer"
+        end
+      end
+
+      def bandwidth_trigger
+        attributes = Thresholds.new(@client).prepare_triggers(
+          host: @host, interface: @line.interface(hostid: @host[:hostid]),
+          items: { inbound_bps: @items[:inbound], outbound_bps: @items[:outbound] },
+          thresholds: { bandwidth: @line.threshold }
+        ).fetch(:bandwidth)
+        attributes[:expression] = guarded(attributes[:expression])
+        attributes[:recovery_expression] = guarded(attributes[:recovery_expression])
+        decorate(attributes)
+      end
+
+      def low_trigger
+        config = @line.low_traffic
+        problem = traffic_expression(config[:window], "<", config[:below_bps], "and")
+        recovery = traffic_expression(config[:recovery_window], ">=", config[:recovery_bps], "or")
+        trigger(:low_traffic, guarded(problem), guarded(recovery), "low traffic")
+      end
+
+      def status_trigger
+        key = @items.fetch(:status).fetch(:key_)
+        trigger(:interface_status, compare(key, "last", nil, "<>", 1),
+                compare(key, "last", nil, "=", 1), "interface down")
+      end
+
+      def reachability_trigger
+        key = @icmp_item.fetch(:attributes).fetch(:key_)
+        trigger(:reachability, compare(key, "max", "5m", "=", 0),
+                compare(key, "min", "2m", "=", 1), "ICMP unreachable")
+      end
+
+      def trigger(kind, problem, recovery, label)
+        key = "interface:#{@line_id}:#{kind}"
+        raise Invalid, "managed_key is too long" if key.length > Triggers::MAX_MANAGED_KEY_LENGTH
+
+        decorate(
+          hostid: @host[:hostid], managed_key: key,
+          description: "#{@line.interface_name} #{label}", expression: problem,
+          recovery_mode: 1, recovery_expression: recovery, priority: @line.threshold[:priority], manual_close: 1,
+          tags: [
+            { tag: "managed_by", value: "zabbix_manager" }, { tag: "interface", value: @line.interface_name },
+            { tag: "metric", value: kind.to_s }
+          ] + @line.threshold[:tags]
+        )
+      end
+
+      def decorate(attributes)
+        attributes.merge(@line.metadata).merge(
+          status: 0, tags: (attributes[:tags] + [{ tag: "line_id", value: @line_id }]).uniq
+        )
+      end
+
+      def guarded(expression)
+        return expression unless @items[:speed]
+
+        "(#{expression}) and #{compare(@items[:speed][:key_], 'last', nil, '>', 0)}"
+      end
+
+      def traffic_expression(window, operator, value, joiner)
+        %i[inbound outbound].map do |direction|
+          compare(@items.fetch(direction).fetch(:key_), "avg", window, operator, value)
+        end.join(" #{joiner} ")
+      end
+
+      def compare(...)
+        @expressions.compare(...)
+      end
+    end
+  end
+end

data/lib/zabbix_manager/monitoring/thresholds.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "zabbix_manager/monitoring/expressions"
+
+class ZabbixManager
+  class Monitoring
+    # 先完整验证监控项和阈值，再生成不含远端副作用的触发器定义。
+    # 不执行 item.get 或写请求；已有监控项的归属及创建必填字段由资源层继续核对。
+    # @api private
+    class Thresholds
+      DEFAULT_WINDOW = "5m"
+      DEFAULT_PRIORITY = 3
+      FUNCTIONS = %w[avg max min last].freeze
+      METRICS = { bandwidth: %i[inbound_bps outbound_bps], errors: %i[in_errors out_errors],
+                  packet_loss: [:packet_loss] }.freeze
+      MANAGED_TAGS = %w[managed_by interface metric zabbix_manager_id].freeze
+      CONFIG_KEYS = %i[metrics capacity_bps high_percent recovery_percent high recovery window
+                       recovery_window function description priority tags].freeze
+
+      def initialize(client)
+        @client = client
+      end
+
+      # 复制原生 item 定义并绑定主机/接口；省略字段保留给资源层默认值与校验处理。
+      # @return [Hash{Symbol => Hash}] 按业务指标名称分组的监控项属性
+      def prepare_items(host, interface, definitions)
+        items = Validation.hash!(definitions, "items").to_h do |metric, attributes|
+          attributes = Validation.hash!(attributes, "item #{metric}")
+          Validation.item_key!(attributes[:key_])
+          attributes[:hostid] = host[:hostid]
+          attributes[:interfaceid] = interface[:interfaceid] if interface[:interfaceid]
+          attributes[:name] = attributes.fetch(:name, "#{interface[:name]} #{metric.to_s.tr('_', ' ')}")
+          Validation.text!(attributes[:name], "item #{metric} name")
+          [metric, attributes]
+        end
+        if items.values.map { |item| item[:key_] }.uniq.length != items.length
+          raise Invalid, "item key_ values must be unique within an interface"
+        end
+
+        items
+      end
+
+      # 高阈值任一方向超限即可告警；所有方向低于或等于恢复值才恢复。
+      # 初次预检可只检查结构；合并远端配置后必须校验完整监控项。
+      # @return [Hash{Symbol => Hash}] 包含表达式、恢复表达式及受管身份的写入属性
+      def prepare_triggers(host:, interface:, items:, thresholds:, validate_items: true)
+        Validation.host!(host)
+        Validation.hash!(thresholds, "thresholds").to_h do |metric, attributes|
+          config = self.class.validate_config!(metric, attributes)
+          selected = select_items(metric, config, items, validate_items: validate_items)
+          high, recovery = self.class.values(metric, config)
+          function = config.fetch(:function, "avg")
+          window = config.fetch(:window, DEFAULT_WINDOW)
+          description = config.fetch(:description, "#{interface[:name]} #{metric.to_s.tr('_', ' ')} high")
+          Validation.text!(description, "threshold #{metric} description")
+          keys = selected.map { |item| Validation.item_key!(item[:key_]) }
+          [metric, {
+            hostid: host[:hostid], description: description,
+            expression: expression(host[:host], keys, function, window, ">", high, "or"),
+            recovery_mode: 1,
+            recovery_expression: expression(host[:host], keys, function,
+                                            config.fetch(:recovery_window, window), "<=", recovery, "and"),
+            priority: Validation.priority!(config.fetch(:priority, DEFAULT_PRIORITY)), manual_close: 1,
+            tags: managed_tags(interface[:name], metric, config.fetch(:tags, [])),
+            managed_key: managed_key(interface, metric)
+          }]
+        end
+      end
+
+      def self.validate_config!(metric, attributes)
+        raise Invalid, "unsupported threshold #{metric}" unless METRICS.key?(metric)
+
+        config = Validation.hash!(attributes, "threshold #{metric}")
+        config.assert_valid_keys(*CONFIG_KEYS)
+        Validation.window!(config.fetch(:window, DEFAULT_WINDOW))
+        Validation.window!(config.fetch(:recovery_window, config.fetch(:window, DEFAULT_WINDOW)))
+        Validation.priority!(config.fetch(:priority, DEFAULT_PRIORITY))
+        unless FUNCTIONS.include?(config.fetch(:function, "avg"))
+          raise Invalid, "function must be one of #{FUNCTIONS.join(', ')}"
+        end
+
+        high, recovery = values(metric, config)
+        unless high.finite? && recovery.finite? && high.positive? && recovery >= 0 && recovery < high
+          raise Invalid, "#{metric} thresholds must be finite with recovery non-negative and lower than high"
+        end
+        if metric == :packet_loss && high > 100
+          raise Invalid, "packet_loss high must be at most 100 percent"
+        end
+
+        config
+      rescue ArgumentError => error
+        raise Invalid, error.message
+      end
+
+      def self.values(metric, config)
+        if metric == :bandwidth
+          capacity = Validation.number!(config[:capacity_bps], "bandwidth capacity_bps")
+          high = Validation.number!(config[:high_percent], "bandwidth high_percent")
+          recovery = Validation.number!(config[:recovery_percent], "bandwidth recovery_percent")
+          unless capacity.positive? && high.between?(0, 100) && recovery.between?(0, 100)
+            raise Invalid, "bandwidth capacity must be positive and percentages must be between 0 and 100"
+          end
+
+          [capacity * (high / 100), capacity * (recovery / 100)]
+        else
+          [Validation.number!(config[:high], "#{metric} high"),
+           Validation.number!(config[:recovery], "#{metric} recovery")]
+        end
+      end
+
+      private
+
+      def select_items(metric, config, items, validate_items:)
+        names = Validation.array!(config.fetch(:metrics, METRICS.fetch(metric)), "threshold metrics")
+        raise Invalid, "threshold #{metric} requires at least one item" if names.empty?
+
+        names.map do |name|
+          unless name.is_a?(String) || name.is_a?(Symbol)
+            raise Invalid, "threshold metric names must be strings or symbols"
+          end
+
+          item = items.fetch(name.to_sym) { raise Invalid, "threshold #{metric} requires item metric #{name}" }
+          validate_units!(metric, item) if validate_items
+          item
+        end
+      end
+
+      def validate_units!(metric, item)
+        if item.key?(:value_type) && !%w[0 3].include?(item[:value_type].to_s)
+          raise Invalid, "threshold #{metric} requires a numeric value_type"
+        end
+
+        case metric
+        when :bandwidth
+          TrafficItems.validate_bps!(item)
+        when :errors
+          steps = Validation.array!(item.fetch(:preprocessing, []), "error preprocessing")
+                            .map { |step| Validation.hash!(step, "error preprocessing step") }
+          rate_step = steps.any? { |step| step[:type].to_s == "10" }
+          explicit_rate = [item[:key_], item[:name]].join(" ").match?(/(?:\brate\b|[._]rate\b|per[._ -]?second)/i)
+          unless rate_step || explicit_rate
+            raise Invalid, "error metric #{item[:key_]} must represent a per-second rate"
+          end
+        when :packet_loss
+          raise Invalid, "packet loss metric #{item[:key_]} must use % units" unless item[:units] == "%"
+        end
+      end
+
+      def expression(host, keys, function, window, operator, threshold, joiner)
+        expressions = Expressions.new(@client, host)
+        keys.map { |key| expressions.compare(key, function, window, operator, threshold) }.join(" #{joiner} ")
+      end
+
+      def managed_tags(interface_name, metric, extra_tags)
+        tags = [
+          { tag: "managed_by", value: "zabbix_manager" },
+          { tag: "interface", value: interface_name },
+          { tag: "metric", value: metric.to_s }
+        ]
+        extra = Validation.array!(extra_tags, "threshold tags").map do |tag|
+          tag = Validation.hash!(tag, "threshold tag")
+          tag.assert_valid_keys(:tag, :value)
+          Validation.text!(tag[:tag], "threshold tag name")
+          raise Invalid, "threshold tag #{tag[:tag]} is reserved" if MANAGED_TAGS.include?(tag[:tag])
+          raise Invalid, "threshold tag value must be a string" unless tag.fetch(:value, "").is_a?(String)
+
+          { tag: tag[:tag], value: tag.fetch(:value, "") }
+        end
+        (tags + extra).uniq
+      end
+
+      def managed_key(interface, metric)
+        identity = interface[:line_id].presence || interface[:interfaceid].presence ||
+                   TrafficItems.interface_identity(interface[:name])
+        key = "interface:#{identity}:#{metric}"
+        raise Invalid, "managed_key is too long" if key.length > Triggers::MAX_MANAGED_KEY_LENGTH
+
+        key
+      end
+    end
+  end
+end