Class: Smplkit::Audit::ForwarderEnvironment

Inherits:
Struct
  • Object
show all
Defined in:
lib/smplkit/audit/models.rb

Overview

One environment’s *sparse override* for a forwarder (ADR-056).

A forwarder’s Smplkit::Audit::Forwarder#environments map holds one of these per environment. Only the leaves you set are sent on save; everything you leave unset is inherited from the forwarder’s base definition, and the server resolves base ⊕ overrides when an event is delivered. The base definition delivers nowhere, so a forwarder delivers in an environment only when that environment’s override sets enabled: true.

Reach one through Smplkit::Audit::Forwarder#environment, e.g. forwarder.environment(“production”).url = “prod.siem.example.com/in”.

*Reading a leaf returns this environment’s override, or nil when it does not override that leaf* — the SDK does not merge in the base value (forwarders resolve server-side). To see a base value, read the forwarder’s base definition (Smplkit::Audit::Forwarder#configuration).

rubocop:disable Lint/StructNewOverride – “:method“ matches the API attribute and shadowing Struct#method is the expected ergonomics.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(enabled: false, url: nil, method: nil, success_status: nil, tls_verify: nil, ca_cert: nil, headers: nil) ⇒ ForwarderEnvironment

Returns a new instance of ForwarderEnvironment.



483
484
485
486
487
488
489
 
# File 'lib/smplkit/audit/models.rb', line 483

def initialize(enabled: false, url: nil, method: nil, success_status: nil,
               tls_verify: nil, ca_cert: nil, headers: nil)
  super(
    enabled: enabled, url: url, method: method, success_status: success_status,
    tls_verify: tls_verify, ca_cert: ca_cert, headers: (headers || {}).transform_keys(&:to_s)
  )
end

Instance Attribute Details

#ca_cert ⇒ String?

Returns Per-environment CA-cert override. nil inherits the base.

Returns:

  • (String, nil) —

    Per-environment CA-cert override. nil inherits the base.



479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
 
# File 'lib/smplkit/audit/models.rb', line 479

ForwarderEnvironment = Struct.new(
  :enabled, :url, :method, :success_status, :tls_verify, :ca_cert, :headers,
  keyword_init: true
) do
  def initialize(enabled: false, url: nil, method: nil, success_status: nil,
                 tls_verify: nil, ca_cert: nil, headers: nil)
    super(
      enabled: enabled, url: url, method: method, success_status: success_status,
      tls_verify: tls_verify, ca_cert: ca_cert, headers: (headers || {}).transform_keys(&:to_s)
    )
  end

  # Override (or add) a single header by name in this environment.
  #
  # @param name [String] Header name.
  # @param value [String] Header value.
  def set_header(name, value)
    self.headers ||= {}
    headers[name.to_s] = value
  end

  # This environment's override for header +name+, or +nil+ when it does not
  # override that header.
  #
  # @param name [String] Header name.
  # @return [String, nil]
  def get_header(name)
    (headers || {})[name.to_s]
  end

  # @api private — Emit the flat sparse leaf-path overlay (ADR-056): +enabled+
  #   plus only the leaves this environment overrides, with each header as a
  #   +headers.<name>+ leaf.
  #
  # @return [Hash{String => Object}]
  def to_payload
    payload = { "enabled" => enabled }
    FORWARDER_ENV_SCALAR_LEAVES.each do |leaf|
      value = self[leaf]
      payload[leaf.to_s] = value unless value.nil?
    end
    (headers || {}).each { |name, value| payload["headers.#{name}"] = value }
    payload
  end

  # @api private — Parse the flat leaf-path overlay the server returns
  #   (ADR-056). Header leaves arrive as +headers.<name>+ (split on the first
  #   dot, so a dotted header name like +X-Foo.Bar+ is preserved); every other
  #   leaf is a single top-level key. Unknown leaves are ignored for forward
  #   compatibility. Keys may be symbols or strings.
  #
  # @param raw [Hash, nil] The flat overlay hash, or +nil+ for an empty override.
  # @return [ForwarderEnvironment]
  def self.from_flat(raw)
    return new if raw.nil?

    headers = {}
    scalars = {}
    (raw || {}).each do |key, value|
      key = key.to_s
      group, _dot, name = key.partition(".")
      if group == "headers" && !name.empty?
        headers[name] = value
      elsif FORWARDER_ENV_SCALAR_LEAF_NAMES.include?(key) || key == "enabled"
        scalars[key] = value
      end
    end
    new(
      enabled: scalars["enabled"] ? true : false,
      url: scalars["url"], method: scalars["method"],
      success_status: scalars["success_status"], tls_verify: scalars["tls_verify"],
      ca_cert: scalars["ca_cert"], headers: headers
    )
  end
end

#enabled ⇒ Boolean

Returns Whether the forwarder delivers events in this environment. Defaults to false.

Returns:

  • (Boolean) —

    Whether the forwarder delivers events in this environment. Defaults to false.



479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
 
# File 'lib/smplkit/audit/models.rb', line 479

ForwarderEnvironment = Struct.new(
  :enabled, :url, :method, :success_status, :tls_verify, :ca_cert, :headers,
  keyword_init: true
) do
  def initialize(enabled: false, url: nil, method: nil, success_status: nil,
                 tls_verify: nil, ca_cert: nil, headers: nil)
    super(
      enabled: enabled, url: url, method: method, success_status: success_status,
      tls_verify: tls_verify, ca_cert: ca_cert, headers: (headers || {}).transform_keys(&:to_s)
    )
  end

  # Override (or add) a single header by name in this environment.
  #
  # @param name [String] Header name.
  # @param value [String] Header value.
  def set_header(name, value)
    self.headers ||= {}
    headers[name.to_s] = value
  end

  # This environment's override for header +name+, or +nil+ when it does not
  # override that header.
  #
  # @param name [String] Header name.
  # @return [String, nil]
  def get_header(name)
    (headers || {})[name.to_s]
  end

  # @api private — Emit the flat sparse leaf-path overlay (ADR-056): +enabled+
  #   plus only the leaves this environment overrides, with each header as a
  #   +headers.<name>+ leaf.
  #
  # @return [Hash{String => Object}]
  def to_payload
    payload = { "enabled" => enabled }
    FORWARDER_ENV_SCALAR_LEAVES.each do |leaf|
      value = self[leaf]
      payload[leaf.to_s] = value unless value.nil?
    end
    (headers || {}).each { |name, value| payload["headers.#{name}"] = value }
    payload
  end

  # @api private — Parse the flat leaf-path overlay the server returns
  #   (ADR-056). Header leaves arrive as +headers.<name>+ (split on the first
  #   dot, so a dotted header name like +X-Foo.Bar+ is preserved); every other
  #   leaf is a single top-level key. Unknown leaves are ignored for forward
  #   compatibility. Keys may be symbols or strings.
  #
  # @param raw [Hash, nil] The flat overlay hash, or +nil+ for an empty override.
  # @return [ForwarderEnvironment]
  def self.from_flat(raw)
    return new if raw.nil?

    headers = {}
    scalars = {}
    (raw || {}).each do |key, value|
      key = key.to_s
      group, _dot, name = key.partition(".")
      if group == "headers" && !name.empty?
        headers[name] = value
      elsif FORWARDER_ENV_SCALAR_LEAF_NAMES.include?(key) || key == "enabled"
        scalars[key] = value
      end
    end
    new(
      enabled: scalars["enabled"] ? true : false,
      url: scalars["url"], method: scalars["method"],
      success_status: scalars["success_status"], tls_verify: scalars["tls_verify"],
      ca_cert: scalars["ca_cert"], headers: headers
    )
  end
end

#headers ⇒ Hash{String => String}

Returns Per-environment header overrides, as a name→value object. Each entry overrides (or adds) that one header by name on top of the base headers, leaving the rest inherited. Use #set_header / #get_header.

Returns:

  • (Hash{String => String}) —

    Per-environment header overrides, as a name→value object. Each entry overrides (or adds) that one header by name on top of the base headers, leaving the rest inherited. Use #set_header / #get_header.



479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
 
# File 'lib/smplkit/audit/models.rb', line 479

ForwarderEnvironment = Struct.new(
  :enabled, :url, :method, :success_status, :tls_verify, :ca_cert, :headers,
  keyword_init: true
) do
  def initialize(enabled: false, url: nil, method: nil, success_status: nil,
                 tls_verify: nil, ca_cert: nil, headers: nil)
    super(
      enabled: enabled, url: url, method: method, success_status: success_status,
      tls_verify: tls_verify, ca_cert: ca_cert, headers: (headers || {}).transform_keys(&:to_s)
    )
  end

  # Override (or add) a single header by name in this environment.
  #
  # @param name [String] Header name.
  # @param value [String] Header value.
  def set_header(name, value)
    self.headers ||= {}
    headers[name.to_s] = value
  end

  # This environment's override for header +name+, or +nil+ when it does not
  # override that header.
  #
  # @param name [String] Header name.
  # @return [String, nil]
  def get_header(name)
    (headers || {})[name.to_s]
  end

  # @api private — Emit the flat sparse leaf-path overlay (ADR-056): +enabled+
  #   plus only the leaves this environment overrides, with each header as a
  #   +headers.<name>+ leaf.
  #
  # @return [Hash{String => Object}]
  def to_payload
    payload = { "enabled" => enabled }
    FORWARDER_ENV_SCALAR_LEAVES.each do |leaf|
      value = self[leaf]
      payload[leaf.to_s] = value unless value.nil?
    end
    (headers || {}).each { |name, value| payload["headers.#{name}"] = value }
    payload
  end

  # @api private — Parse the flat leaf-path overlay the server returns
  #   (ADR-056). Header leaves arrive as +headers.<name>+ (split on the first
  #   dot, so a dotted header name like +X-Foo.Bar+ is preserved); every other
  #   leaf is a single top-level key. Unknown leaves are ignored for forward
  #   compatibility. Keys may be symbols or strings.
  #
  # @param raw [Hash, nil] The flat overlay hash, or +nil+ for an empty override.
  # @return [ForwarderEnvironment]
  def self.from_flat(raw)
    return new if raw.nil?

    headers = {}
    scalars = {}
    (raw || {}).each do |key, value|
      key = key.to_s
      group, _dot, name = key.partition(".")
      if group == "headers" && !name.empty?
        headers[name] = value
      elsif FORWARDER_ENV_SCALAR_LEAF_NAMES.include?(key) || key == "enabled"
        scalars[key] = value
      end
    end
    new(
      enabled: scalars["enabled"] ? true : false,
      url: scalars["url"], method: scalars["method"],
      success_status: scalars["success_status"], tls_verify: scalars["tls_verify"],
      ca_cert: scalars["ca_cert"], headers: headers
    )
  end
end

#method ⇒ String?

Returns Per-environment HTTP-method override. nil inherits the base.

Returns:

  • (String, nil) —

    Per-environment HTTP-method override. nil inherits the base.



479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
 
# File 'lib/smplkit/audit/models.rb', line 479

ForwarderEnvironment = Struct.new(
  :enabled, :url, :method, :success_status, :tls_verify, :ca_cert, :headers,
  keyword_init: true
) do
  def initialize(enabled: false, url: nil, method: nil, success_status: nil,
                 tls_verify: nil, ca_cert: nil, headers: nil)
    super(
      enabled: enabled, url: url, method: method, success_status: success_status,
      tls_verify: tls_verify, ca_cert: ca_cert, headers: (headers || {}).transform_keys(&:to_s)
    )
  end

  # Override (or add) a single header by name in this environment.
  #
  # @param name [String] Header name.
  # @param value [String] Header value.
  def set_header(name, value)
    self.headers ||= {}
    headers[name.to_s] = value
  end

  # This environment's override for header +name+, or +nil+ when it does not
  # override that header.
  #
  # @param name [String] Header name.
  # @return [String, nil]
  def get_header(name)
    (headers || {})[name.to_s]
  end

  # @api private — Emit the flat sparse leaf-path overlay (ADR-056): +enabled+
  #   plus only the leaves this environment overrides, with each header as a
  #   +headers.<name>+ leaf.
  #
  # @return [Hash{String => Object}]
  def to_payload
    payload = { "enabled" => enabled }
    FORWARDER_ENV_SCALAR_LEAVES.each do |leaf|
      value = self[leaf]
      payload[leaf.to_s] = value unless value.nil?
    end
    (headers || {}).each { |name, value| payload["headers.#{name}"] = value }
    payload
  end

  # @api private — Parse the flat leaf-path overlay the server returns
  #   (ADR-056). Header leaves arrive as +headers.<name>+ (split on the first
  #   dot, so a dotted header name like +X-Foo.Bar+ is preserved); every other
  #   leaf is a single top-level key. Unknown leaves are ignored for forward
  #   compatibility. Keys may be symbols or strings.
  #
  # @param raw [Hash, nil] The flat overlay hash, or +nil+ for an empty override.
  # @return [ForwarderEnvironment]
  def self.from_flat(raw)
    return new if raw.nil?

    headers = {}
    scalars = {}
    (raw || {}).each do |key, value|
      key = key.to_s
      group, _dot, name = key.partition(".")
      if group == "headers" && !name.empty?
        headers[name] = value
      elsif FORWARDER_ENV_SCALAR_LEAF_NAMES.include?(key) || key == "enabled"
        scalars[key] = value
      end
    end
    new(
      enabled: scalars["enabled"] ? true : false,
      url: scalars["url"], method: scalars["method"],
      success_status: scalars["success_status"], tls_verify: scalars["tls_verify"],
      ca_cert: scalars["ca_cert"], headers: headers
    )
  end
end

#success_status ⇒ String?

Returns Per-environment success-status override. nil inherits the base.

Returns:

  • (String, nil) —

    Per-environment success-status override. nil inherits the base.



479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
 
# File 'lib/smplkit/audit/models.rb', line 479

ForwarderEnvironment = Struct.new(
  :enabled, :url, :method, :success_status, :tls_verify, :ca_cert, :headers,
  keyword_init: true
) do
  def initialize(enabled: false, url: nil, method: nil, success_status: nil,
                 tls_verify: nil, ca_cert: nil, headers: nil)
    super(
      enabled: enabled, url: url, method: method, success_status: success_status,
      tls_verify: tls_verify, ca_cert: ca_cert, headers: (headers || {}).transform_keys(&:to_s)
    )
  end

  # Override (or add) a single header by name in this environment.
  #
  # @param name [String] Header name.
  # @param value [String] Header value.
  def set_header(name, value)
    self.headers ||= {}
    headers[name.to_s] = value
  end

  # This environment's override for header +name+, or +nil+ when it does not
  # override that header.
  #
  # @param name [String] Header name.
  # @return [String, nil]
  def get_header(name)
    (headers || {})[name.to_s]
  end

  # @api private — Emit the flat sparse leaf-path overlay (ADR-056): +enabled+
  #   plus only the leaves this environment overrides, with each header as a
  #   +headers.<name>+ leaf.
  #
  # @return [Hash{String => Object}]
  def to_payload
    payload = { "enabled" => enabled }
    FORWARDER_ENV_SCALAR_LEAVES.each do |leaf|
      value = self[leaf]
      payload[leaf.to_s] = value unless value.nil?
    end
    (headers || {}).each { |name, value| payload["headers.#{name}"] = value }
    payload
  end

  # @api private — Parse the flat leaf-path overlay the server returns
  #   (ADR-056). Header leaves arrive as +headers.<name>+ (split on the first
  #   dot, so a dotted header name like +X-Foo.Bar+ is preserved); every other
  #   leaf is a single top-level key. Unknown leaves are ignored for forward
  #   compatibility. Keys may be symbols or strings.
  #
  # @param raw [Hash, nil] The flat overlay hash, or +nil+ for an empty override.
  # @return [ForwarderEnvironment]
  def self.from_flat(raw)
    return new if raw.nil?

    headers = {}
    scalars = {}
    (raw || {}).each do |key, value|
      key = key.to_s
      group, _dot, name = key.partition(".")
      if group == "headers" && !name.empty?
        headers[name] = value
      elsif FORWARDER_ENV_SCALAR_LEAF_NAMES.include?(key) || key == "enabled"
        scalars[key] = value
      end
    end
    new(
      enabled: scalars["enabled"] ? true : false,
      url: scalars["url"], method: scalars["method"],
      success_status: scalars["success_status"], tls_verify: scalars["tls_verify"],
      ca_cert: scalars["ca_cert"], headers: headers
    )
  end
end

#tls_verify ⇒ Boolean?

Returns Per-environment TLS-verify override. nil inherits the base.

Returns:

  • (Boolean, nil) —

    Per-environment TLS-verify override. nil inherits the base.



479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
 
# File 'lib/smplkit/audit/models.rb', line 479

ForwarderEnvironment = Struct.new(
  :enabled, :url, :method, :success_status, :tls_verify, :ca_cert, :headers,
  keyword_init: true
) do
  def initialize(enabled: false, url: nil, method: nil, success_status: nil,
                 tls_verify: nil, ca_cert: nil, headers: nil)
    super(
      enabled: enabled, url: url, method: method, success_status: success_status,
      tls_verify: tls_verify, ca_cert: ca_cert, headers: (headers || {}).transform_keys(&:to_s)
    )
  end

  # Override (or add) a single header by name in this environment.
  #
  # @param name [String] Header name.
  # @param value [String] Header value.
  def set_header(name, value)
    self.headers ||= {}
    headers[name.to_s] = value
  end

  # This environment's override for header +name+, or +nil+ when it does not
  # override that header.
  #
  # @param name [String] Header name.
  # @return [String, nil]
  def get_header(name)
    (headers || {})[name.to_s]
  end

  # @api private — Emit the flat sparse leaf-path overlay (ADR-056): +enabled+
  #   plus only the leaves this environment overrides, with each header as a
  #   +headers.<name>+ leaf.
  #
  # @return [Hash{String => Object}]
  def to_payload
    payload = { "enabled" => enabled }
    FORWARDER_ENV_SCALAR_LEAVES.each do |leaf|
      value = self[leaf]
      payload[leaf.to_s] = value unless value.nil?
    end
    (headers || {}).each { |name, value| payload["headers.#{name}"] = value }
    payload
  end

  # @api private — Parse the flat leaf-path overlay the server returns
  #   (ADR-056). Header leaves arrive as +headers.<name>+ (split on the first
  #   dot, so a dotted header name like +X-Foo.Bar+ is preserved); every other
  #   leaf is a single top-level key. Unknown leaves are ignored for forward
  #   compatibility. Keys may be symbols or strings.
  #
  # @param raw [Hash, nil] The flat overlay hash, or +nil+ for an empty override.
  # @return [ForwarderEnvironment]
  def self.from_flat(raw)
    return new if raw.nil?

    headers = {}
    scalars = {}
    (raw || {}).each do |key, value|
      key = key.to_s
      group, _dot, name = key.partition(".")
      if group == "headers" && !name.empty?
        headers[name] = value
      elsif FORWARDER_ENV_SCALAR_LEAF_NAMES.include?(key) || key == "enabled"
        scalars[key] = value
      end
    end
    new(
      enabled: scalars["enabled"] ? true : false,
      url: scalars["url"], method: scalars["method"],
      success_status: scalars["success_status"], tls_verify: scalars["tls_verify"],
      ca_cert: scalars["ca_cert"], headers: headers
    )
  end
end

#url ⇒ String?

Returns Per-environment URL override. nil inherits the base.

Returns:

  • (String, nil) —

    Per-environment URL override. nil inherits the base.



479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
 
# File 'lib/smplkit/audit/models.rb', line 479

ForwarderEnvironment = Struct.new(
  :enabled, :url, :method, :success_status, :tls_verify, :ca_cert, :headers,
  keyword_init: true
) do
  def initialize(enabled: false, url: nil, method: nil, success_status: nil,
                 tls_verify: nil, ca_cert: nil, headers: nil)
    super(
      enabled: enabled, url: url, method: method, success_status: success_status,
      tls_verify: tls_verify, ca_cert: ca_cert, headers: (headers || {}).transform_keys(&:to_s)
    )
  end

  # Override (or add) a single header by name in this environment.
  #
  # @param name [String] Header name.
  # @param value [String] Header value.
  def set_header(name, value)
    self.headers ||= {}
    headers[name.to_s] = value
  end

  # This environment's override for header +name+, or +nil+ when it does not
  # override that header.
  #
  # @param name [String] Header name.
  # @return [String, nil]
  def get_header(name)
    (headers || {})[name.to_s]
  end

  # @api private — Emit the flat sparse leaf-path overlay (ADR-056): +enabled+
  #   plus only the leaves this environment overrides, with each header as a
  #   +headers.<name>+ leaf.
  #
  # @return [Hash{String => Object}]
  def to_payload
    payload = { "enabled" => enabled }
    FORWARDER_ENV_SCALAR_LEAVES.each do |leaf|
      value = self[leaf]
      payload[leaf.to_s] = value unless value.nil?
    end
    (headers || {}).each { |name, value| payload["headers.#{name}"] = value }
    payload
  end

  # @api private — Parse the flat leaf-path overlay the server returns
  #   (ADR-056). Header leaves arrive as +headers.<name>+ (split on the first
  #   dot, so a dotted header name like +X-Foo.Bar+ is preserved); every other
  #   leaf is a single top-level key. Unknown leaves are ignored for forward
  #   compatibility. Keys may be symbols or strings.
  #
  # @param raw [Hash, nil] The flat overlay hash, or +nil+ for an empty override.
  # @return [ForwarderEnvironment]
  def self.from_flat(raw)
    return new if raw.nil?

    headers = {}
    scalars = {}
    (raw || {}).each do |key, value|
      key = key.to_s
      group, _dot, name = key.partition(".")
      if group == "headers" && !name.empty?
        headers[name] = value
      elsif FORWARDER_ENV_SCALAR_LEAF_NAMES.include?(key) || key == "enabled"
        scalars[key] = value
      end
    end
    new(
      enabled: scalars["enabled"] ? true : false,
      url: scalars["url"], method: scalars["method"],
      success_status: scalars["success_status"], tls_verify: scalars["tls_verify"],
      ca_cert: scalars["ca_cert"], headers: headers
    )
  end
end

Class Method Details

.from_flat(raw) ⇒ ForwarderEnvironment

Parameters:

  • raw (Hash, nil) —

    The flat overlay hash, or nil for an empty override.

Returns:



532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
 
# File 'lib/smplkit/audit/models.rb', line 532

def self.from_flat(raw)
  return new if raw.nil?

  headers = {}
  scalars = {}
  (raw || {}).each do |key, value|
    key = key.to_s
    group, _dot, name = key.partition(".")
    if group == "headers" && !name.empty?
      headers[name] = value
    elsif FORWARDER_ENV_SCALAR_LEAF_NAMES.include?(key) || key == "enabled"
      scalars[key] = value
    end
  end
  new(
    enabled: scalars["enabled"] ? true : false,
    url: scalars["url"], method: scalars["method"],
    success_status: scalars["success_status"], tls_verify: scalars["tls_verify"],
    ca_cert: scalars["ca_cert"], headers: headers
  )
end

Instance Method Details

#get_header(name) ⇒ String?

This environment’s override for header name, or nil when it does not override that header.

Parameters:

  • name (String) —

    Header name.

Returns:

  • (String, nil) 


505
506
507
 
# File 'lib/smplkit/audit/models.rb', line 505

def get_header(name)
  (headers || {})[name.to_s]
end

#set_header(name, value) ⇒ Object

Override (or add) a single header by name in this environment.

Parameters:

  • name (String) —

    Header name.

  • value (String) —

    Header value.



495
496
497
498
 
# File 'lib/smplkit/audit/models.rb', line 495

def set_header(name, value)
  self.headers ||= {}
  headers[name.to_s] = value
end

#to_payload ⇒ Hash{String => Object}

Returns:

  • (Hash{String => Object}) 


514
515
516
517
518
519
520
521
522
 
# File 'lib/smplkit/audit/models.rb', line 514

def to_payload
  payload = { "enabled" => enabled }
  FORWARDER_ENV_SCALAR_LEAVES.each do |leaf|
    value = self[leaf]
    payload[leaf.to_s] = value unless value.nil?
  end
  (headers || {}).each { |name, value| payload["headers.#{name}"] = value }
  payload
end