noresponse 8.4.1 → 9.0.0

data/lib/no_response/models/shared/operationalaggregate.rb

@@ -0,0 +1,175 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # One repeatable-read snapshot of retained request diagnostics or webhook attempts. Capture can have gaps and these counts are not a billing ledger. Unattributed keys include older requests and member requests. Queue state is current retained work, not a delivery success denominator.
+      class OperationalAggregate
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :source,
+          Models::Shared::Source,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("source"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Source, false)
+            }
+          }
+        )
+
+        field :from, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("from"), required: true}}
+
+        field :to, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("to"), required: true}}
+
+        field(
+          :as_of,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("as_of"), required: true}}
+        )
+
+        field(
+          :retained_from,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("retained_from"), required: true}}
+        )
+
+        field(
+          :retention_days,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("retention_days"), required: true}}
+        )
+
+        field(
+          :bucket,
+          Models::Shared::RequestAggregateRequestBucket,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("bucket"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::RequestAggregateRequestBucket, false)
+            }
+          }
+        )
+
+        field(
+          :totals,
+          Models::Shared::OperationalAggregateTotals,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("totals"), required: true}}
+        )
+        # Nonempty UTC buckets in ascending order. Counts include all retained matching attempts, without the log page limit.
+        field(
+          :buckets,
+          Crystalline::Array.new(Models::Shared::OperationalAggregateBucket),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("buckets"), required: true}}
+        )
+
+        field(
+          :schema_version,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("schema_version"), required: true}}
+        )
+
+        field(
+          :capture,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("capture"), required: true}}
+        )
+
+        field(
+          :population,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("population"), required: true}}
+        )
+        # Current retained delivery queue, independent of the requested attempt window and status filter. Endpoint filter applies. Does not prove customer enforcement execution.
+        field(
+          :queue,
+          Crystalline::Nilable.new(Models::Shared::OperationalAggregateQueue),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("queue")}}
+        )
+
+        sig {
+          params(
+            source: Models::Shared::Source,
+            from: ::String,
+            to: ::String,
+            as_of: ::String,
+            retained_from: ::String,
+            retention_days: ::Integer,
+            bucket: Models::Shared::RequestAggregateRequestBucket,
+            totals: Models::Shared::OperationalAggregateTotals,
+            buckets: T::Array[Models::Shared::OperationalAggregateBucket],
+            schema_version: ::String,
+            capture: ::String,
+            population: ::String,
+            queue: T.nilable(Models::Shared::OperationalAggregateQueue)
+          )
+            .void
+        }
+        def initialize(
+          source:,
+          from:,
+          to:,
+          as_of:,
+          retained_from:,
+          retention_days:,
+          bucket:,
+          totals:,
+          buckets:,
+          schema_version: "1",
+          capture: "best_effort",
+          population: "retained_attempts",
+          queue: nil
+        )
+          @source = source
+          @from = from
+          @to = to
+          @as_of = as_of
+          @retained_from = retained_from
+          @retention_days = retention_days
+          @bucket = bucket
+          @totals = totals
+          @buckets = buckets
+          unless schema_version == "1"
+            raise ArgumentError, "Invalid value for schema_version"
+          end
+
+          @schema_version = "1"
+          unless capture == "best_effort"
+            raise ArgumentError, "Invalid value for capture"
+          end
+
+          @capture = "best_effort"
+          unless population == "retained_attempts"
+            raise ArgumentError, "Invalid value for population"
+          end
+
+          @population = "retained_attempts"
+          @queue = queue
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @source == other.source
+          return false unless @from == other.from
+          return false unless @to == other.to
+          return false unless @as_of == other.as_of
+          return false unless @retained_from == other.retained_from
+          return false unless @retention_days == other.retention_days
+          return false unless @bucket == other.bucket
+          return false unless @totals == other.totals
+          return false unless @buckets == other.buckets
+          return false unless @schema_version == other.schema_version
+          return false unless @capture == other.capture
+          return false unless @population == other.population
+          return false unless @queue == other.queue
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/operationalaggregate.rbi

@@ -0,0 +1,86 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::OperationalAggregate
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::OperationalAggregate
+  def source
+  end
+
+  def source=(str_)
+  end
+
+  def from
+  end
+
+  def from=(str_)
+  end
+
+  def to
+  end
+
+  def to=(str_)
+  end
+
+  def as_of
+  end
+
+  def as_of=(str_)
+  end
+
+  def retained_from
+  end
+
+  def retained_from=(str_)
+  end
+
+  def retention_days
+  end
+
+  def retention_days=(str_)
+  end
+
+  def bucket
+  end
+
+  def bucket=(str_)
+  end
+
+  def totals
+  end
+
+  def totals=(str_)
+  end
+
+  def buckets
+  end
+
+  def buckets=(str_)
+  end
+
+  def schema_version
+  end
+
+  def schema_version=(str_)
+  end
+
+  def capture
+  end
+
+  def capture=(str_)
+  end
+
+  def population
+  end
+
+  def population=(str_)
+  end
+
+  def queue
+  end
+
+  def queue=(str_)
+  end
+end

data/lib/no_response/models/shared/operationalaggregatebucket.rb

@@ -0,0 +1,149 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class OperationalAggregateBucket
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :start,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("start"), required: true}}
+        )
+
+        field(
+          :attempts,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("attempts"), required: true}}
+        )
+
+        field(
+          :succeeded,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("succeeded"), required: true}}
+        )
+
+        field(
+          :failed,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("failed"), required: true}}
+        )
+
+        field(
+          :client_errors,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("client_errors"), required: true}}
+        )
+
+        field(
+          :server_errors,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("server_errors"), required: true}}
+        )
+
+        field(
+          :replays,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("replays"), required: true}}
+        )
+
+        field(
+          :incomplete_writes,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("incomplete_writes"), required: true}}
+        )
+
+        field(
+          :unattributed_keys,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("unattributed_keys"), required: true}}
+        )
+        # Continuous percentile over retained attempts. Omitted when there are no captured samples.
+        field(
+          :p50_ms,
+          Crystalline::Nilable.new(::Float),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("p50_ms")}}
+        )
+        # Continuous percentile over retained attempts. Omitted when there are no captured samples.
+        field(
+          :p95_ms,
+          Crystalline::Nilable.new(::Float),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("p95_ms")}}
+        )
+        # Continuous percentile over retained attempts. Omitted when there are no captured samples.
+        field(
+          :p99_ms,
+          Crystalline::Nilable.new(::Float),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("p99_ms")}}
+        )
+
+        sig {
+          params(
+            start: ::String,
+            attempts: ::Integer,
+            succeeded: ::Integer,
+            failed: ::Integer,
+            client_errors: ::Integer,
+            server_errors: ::Integer,
+            replays: ::Integer,
+            incomplete_writes: ::Integer,
+            unattributed_keys: ::Integer,
+            p50_ms: T.nilable(::Float),
+            p95_ms: T.nilable(::Float),
+            p99_ms: T.nilable(::Float)
+          )
+            .void
+        }
+        def initialize(
+          start:,
+          attempts:,
+          succeeded:,
+          failed:,
+          client_errors:,
+          server_errors:,
+          replays:,
+          incomplete_writes:,
+          unattributed_keys:,
+          p50_ms: nil,
+          p95_ms: nil,
+          p99_ms: nil
+        )
+          @start = start
+          @attempts = attempts
+          @succeeded = succeeded
+          @failed = failed
+          @client_errors = client_errors
+          @server_errors = server_errors
+          @replays = replays
+          @incomplete_writes = incomplete_writes
+          @unattributed_keys = unattributed_keys
+          @p50_ms = p50_ms
+          @p95_ms = p95_ms
+          @p99_ms = p99_ms
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @start == other.start
+          return false unless @attempts == other.attempts
+          return false unless @succeeded == other.succeeded
+          return false unless @failed == other.failed
+          return false unless @client_errors == other.client_errors
+          return false unless @server_errors == other.server_errors
+          return false unless @replays == other.replays
+          return false unless @incomplete_writes == other.incomplete_writes
+          return false unless @unattributed_keys == other.unattributed_keys
+          return false unless @p50_ms == other.p50_ms
+          return false unless @p95_ms == other.p95_ms
+          return false unless @p99_ms == other.p99_ms
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/operationalaggregatebucket.rbi

@@ -0,0 +1,80 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::OperationalAggregateBucket
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::OperationalAggregateBucket
+  def start
+  end
+
+  def start=(str_)
+  end
+
+  def attempts
+  end
+
+  def attempts=(str_)
+  end
+
+  def succeeded
+  end
+
+  def succeeded=(str_)
+  end
+
+  def failed
+  end
+
+  def failed=(str_)
+  end
+
+  def client_errors
+  end
+
+  def client_errors=(str_)
+  end
+
+  def server_errors
+  end
+
+  def server_errors=(str_)
+  end
+
+  def replays
+  end
+
+  def replays=(str_)
+  end
+
+  def incomplete_writes
+  end
+
+  def incomplete_writes=(str_)
+  end
+
+  def unattributed_keys
+  end
+
+  def unattributed_keys=(str_)
+  end
+
+  def p50_ms
+  end
+
+  def p50_ms=(str_)
+  end
+
+  def p95_ms
+  end
+
+  def p95_ms=(str_)
+  end
+
+  def p99_ms
+  end
+
+  def p99_ms=(str_)
+  end
+end

data/lib/no_response/models/shared/operationalaggregatequeue.rb

@@ -0,0 +1,64 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Current retained delivery queue, independent of the requested attempt window and status filter. Endpoint filter applies. Does not prove customer enforcement execution.
+      class OperationalAggregateQueue
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :pending,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("pending"), required: true}}
+        )
+
+        field(
+          :leased,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("leased"), required: true}}
+        )
+
+        field(
+          :dead_retained,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("dead_retained"), required: true}}
+        )
+
+        field(
+          :oldest_pending_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("oldest_pending_at")}}
+        )
+
+        sig {
+          params(
+            pending: ::Integer,
+            leased: ::Integer,
+            dead_retained: ::Integer,
+            oldest_pending_at: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(pending:, leased:, dead_retained:, oldest_pending_at: nil)
+          @pending = pending
+          @leased = leased
+          @dead_retained = dead_retained
+          @oldest_pending_at = oldest_pending_at
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @pending == other.pending
+          return false unless @leased == other.leased
+          return false unless @dead_retained == other.dead_retained
+          return false unless @oldest_pending_at == other.oldest_pending_at
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/operationalaggregatequeue.rbi

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::OperationalAggregateQueue
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::OperationalAggregateQueue
+  def pending
+  end
+
+  def pending=(str_)
+  end
+
+  def leased
+  end
+
+  def leased=(str_)
+  end
+
+  def dead_retained
+  end
+
+  def dead_retained=(str_)
+  end
+
+  def oldest_pending_at
+  end
+
+  def oldest_pending_at=(str_)
+  end
+end