smplkit 3.0.133 → 3.0.134

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb735320cad6cc35e02d16ba48a6a95b307b5befd743f0971511a719c92cc376
-  data.tar.gz: d49318a508cb0f2ebd7387bc1ee3c201c491df7bf18a2177d7dd69cdf03d631b
+  metadata.gz: cf2f498b2e69289af423a44bb47b11c024cb9fa6f6a5d92c59c9386a2495636c
+  data.tar.gz: 6427e58289966df501d6484c772c662256e16536d346b60681268bb1f7a93aba
 SHA512:
-  metadata.gz: 3ae89d87c1e2c1df13c09adead2ead58f590e2f8d0a58324772aa56c655962686aa492e592f8c614eae5840cbe77af389703970ebcf802b1c0822de43f362861
-  data.tar.gz: 60844a59a76a58e7917690e145d4432cc7082231ffd409161c6880a38676dd8fa0e58527244f08387d5a5ce46482f465c4b82cdfa3b2bd934472039e23f047a9
+  metadata.gz: 1f34027f5bd130aab9c529b2336c81bae00c1ebe17c28128a3abddd9ba6adeea2c437a858e7aaba2f008a4526dc5eb09240c4e569f07dd2071179f653c449078
+  data.tar.gz: 5c341e78b89c8a5b8ad314a7fd75867b8937817dbe43e86b4f7f572acbbb73ed4d6ac11a9aea05fa83a98a0c29f3cb46efeb174a6693be6374d54068e0b4fa59

data/lib/smplkit/_generated/jobs/lib/smplkit_jobs_client/api/runs_api.rb

@@ -145,6 +145,76 @@ module SmplkitGeneratedClient::Jobs
       return data, status_code, headers
     end
 
+    # Get Run Stats
+    # Report aggregated statistics over this account's runs.  One request answers the common monitoring questions: how many runs matched the filters (`total`), how they broke down by lifecycle state (`tally`), how they were distributed over time (`buckets`, when the `bucket` directive is given), which runs failed most recently (`recent_failures`, at most 3, newest first), and what fires next (`next_scheduled`).  Filters compose with AND:  - `filter[created_at]` — a half-open `[start,end)` date range (see the   parameter for the interval syntax). - `filter[environment]` — one environment key or a comma-separated list   (any-of); omitted covers every environment you can access.  `next_scheduled` honors only the environment filter: it reports the soonest `PENDING` run with a fire time at or after the request, no matter when that run was created.  The resource id is always `current` — statistics are computed at read time, not stored.
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :filter_created_at Restrict the statistics to runs whose `created_at` falls in a half-open `[start,end)` interval. Bounds are ISO-8601 timestamps; `*` leaves a bound open. The leading bracket is `[` (inclusive) or `(` (exclusive) and the trailing bracket is `]` (inclusive) or `)` (exclusive). Example: `[2026-06-01T00:00:00Z,*)` covers everything from June 1 onward. Does not apply to `next_scheduled`.
+    # @option opts [String] :filter_environment Comma-separated list of environment keys to scope the statistics to (e.g. `production,staging`). When omitted, statistics cover every environment you can access.
+    # @option opts [String] :bucket Also return run counts over time, grouped into buckets of this size (a directive, not a filter). One of `1m`, `5m`, `15m`, `1h`, `6h`, or `1d`. Omit to skip the time series.
+    # @return [RunStatsResponse]
+    def get_run_stats(opts = {})
+      data, _status_code, _headers = get_run_stats_with_http_info(opts)
+      data
+    end
+
+    # Get Run Stats
+    # Report aggregated statistics over this account's runs.  One request answers the common monitoring questions: how many runs matched the filters (`total`), how they broke down by lifecycle state (`tally`), how they were distributed over time (`buckets`, when the `bucket` directive is given), which runs failed most recently (`recent_failures`, at most 3, newest first), and what fires next (`next_scheduled`).  Filters compose with AND:  - `filter[created_at]` — a half-open `[start,end)` date range (see the   parameter for the interval syntax). - `filter[environment]` — one environment key or a comma-separated list   (any-of); omitted covers every environment you can access.  `next_scheduled` honors only the environment filter: it reports the soonest `PENDING` run with a fire time at or after the request, no matter when that run was created.  The resource id is always `current` — statistics are computed at read time, not stored.
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :filter_created_at Restrict the statistics to runs whose `created_at` falls in a half-open `[start,end)` interval. Bounds are ISO-8601 timestamps; `*` leaves a bound open. The leading bracket is `[` (inclusive) or `(` (exclusive) and the trailing bracket is `]` (inclusive) or `)` (exclusive). Example: `[2026-06-01T00:00:00Z,*)` covers everything from June 1 onward. Does not apply to `next_scheduled`.
+    # @option opts [String] :filter_environment Comma-separated list of environment keys to scope the statistics to (e.g. `production,staging`). When omitted, statistics cover every environment you can access.
+    # @option opts [String] :bucket Also return run counts over time, grouped into buckets of this size (a directive, not a filter). One of `1m`, `5m`, `15m`, `1h`, `6h`, or `1d`. Omit to skip the time series.
+    # @return [Array<(RunStatsResponse, Integer, Hash)>] RunStatsResponse data, response status code and response headers
+    def get_run_stats_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: RunsApi.get_run_stats ...'
+      end
+      allowable_values = ["1m", "5m", "15m", "1h", "6h", "1d"]
+      if @api_client.config.client_side_validation && opts[:'bucket'] && !allowable_values.include?(opts[:'bucket'])
+        fail ArgumentError, "invalid value for \"bucket\", must be one of #{allowable_values}"
+      end
+      # resource path
+      local_var_path = '/api/v1/run_stats'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+      query_params[:'filter[created_at]'] = opts[:'filter_created_at'] if !opts[:'filter_created_at'].nil?
+      query_params[:'filter[environment]'] = opts[:'filter_environment'] if !opts[:'filter_environment'].nil?
+      query_params[:'bucket'] = opts[:'bucket'] if !opts[:'bucket'].nil?
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/vnd.api+json']) unless header_params['Accept']
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'RunStatsResponse'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['HTTPBearer']
+
+      new_options = opts.merge(
+        :operation => :"RunsApi.get_run_stats",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: RunsApi#get_run_stats\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # List Runs
     # List runs for this account (cursor paginated).  Default sort is `-created_at` (newest first). Sort by `created_at`, `started_at`, `finished_at`, `scheduled_for`, `status`, `job`, or `total_duration_ms`, ascending or descending (prefix `-` for descending). Keep the same `sort` value across paginated requests so the cursor stays consistent. Runs that have not reached the relevant lifecycle point (`started_at`, `finished_at`, `scheduled_for`, `total_duration_ms` unset) sort to the end regardless of direction.  Filters compose with AND:  - `filter[job]={id}` — a single job's run history. - `filter[status]` — one state or a comma-separated list (any-of). - `filter[trigger]` — one trigger (`SCHEDULE`, `MANUAL`, `RERUN`, `RETRY`)   or a comma-separated list of them (any-of). - `filter[environment]` — one environment key or a comma-separated list   (any-of); omitted covers every environment you can access. - `filter[created_at]` / `filter[started_at]` / `filter[finished_at]` /   `filter[scheduled_for]` — half-open `[start,end)` date ranges (see each   parameter for the interval syntax).  Set `last_run_only=true` to collapse the result to the last completed run for each job-and-environment combination. \"Completed\" means a terminal state — succeeded, failed, or canceled; in-flight runs (pending or running) are not included, so a job that is mid-run still surfaces its previous completed result and a combination with no completed run yet returns nothing. The filters above still apply, evaluated before the collapse, so each row is the most recent completed run in its group that also satisfies them.
     # @param [Hash] opts the optional parameters

data/lib/smplkit/_generated/jobs/lib/smplkit_jobs_client/models/run_stat.rb

@@ -0,0 +1,246 @@
+=begin
+#smplkit Jobs API
+
+#Scheduled HTTP job execution API for smplkit.
+
+The version of the OpenAPI document: 0.1.0
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.22.0
+
+=end
+
+require 'date'
+require 'time'
+
+module SmplkitGeneratedClient::Jobs
+  # Aggregated run statistics for the requested scope.  Computed on demand from the account's runs; `total`, `tally`, `buckets`, and `recent_failures` honor the request's filters, while `next_scheduled` honors only the environment filter (it is forward-looking by definition).
+  class RunStat < ApiModelBase
+    # Runs matching the filters.
+    attr_accessor :total
+
+    # Those runs counted by lifecycle state.
+    attr_accessor :tally
+
+    # Run counts over time at the requested `bucket` granularity, ordered by bucket start. Only buckets containing at least one run are listed — treat missing buckets as zero. `null` when the request did not include the `bucket` directive.
+    attr_accessor :buckets
+
+    # The most recently created `FAILED` runs matching the filters, newest first — at most 3.
+    attr_accessor :recent_failures
+
+    # The soonest `PENDING` run with a fire time at or after the request, or `null` when nothing upcoming is scheduled. The `filter[created_at]` range does not apply here — a run scheduled long ago for a future fire time is still next.
+    attr_accessor :next_scheduled
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'total' => :'total',
+        :'tally' => :'tally',
+        :'buckets' => :'buckets',
+        :'recent_failures' => :'recent_failures',
+        :'next_scheduled' => :'next_scheduled'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'total' => :'Integer',
+        :'tally' => :'RunStatTally',
+        :'buckets' => :'Array<RunStatBucket>',
+        :'recent_failures' => :'Array<RunStatFailure>',
+        :'next_scheduled' => :'RunStatNextScheduled'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+        :'buckets',
+        :'next_scheduled'
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `SmplkitGeneratedClient::Jobs::RunStat` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `SmplkitGeneratedClient::Jobs::RunStat`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'total')
+        self.total = attributes[:'total']
+      else
+        self.total = nil
+      end
+
+      if attributes.key?(:'tally')
+        self.tally = attributes[:'tally']
+      else
+        self.tally = nil
+      end
+
+      if attributes.key?(:'buckets')
+        if (value = attributes[:'buckets']).is_a?(Array)
+          self.buckets = value
+        end
+      end
+
+      if attributes.key?(:'recent_failures')
+        if (value = attributes[:'recent_failures']).is_a?(Array)
+          self.recent_failures = value
+        end
+      else
+        self.recent_failures = nil
+      end
+
+      if attributes.key?(:'next_scheduled')
+        self.next_scheduled = attributes[:'next_scheduled']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @total.nil?
+        invalid_properties.push('invalid value for "total", total cannot be nil.')
+      end
+
+      if @tally.nil?
+        invalid_properties.push('invalid value for "tally", tally cannot be nil.')
+      end
+
+      if @recent_failures.nil?
+        invalid_properties.push('invalid value for "recent_failures", recent_failures cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @total.nil?
+      return false if @tally.nil?
+      return false if @recent_failures.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] total Value to be assigned
+    def total=(total)
+      if total.nil?
+        fail ArgumentError, 'total cannot be nil'
+      end
+
+      @total = total
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] tally Value to be assigned
+    def tally=(tally)
+      if tally.nil?
+        fail ArgumentError, 'tally cannot be nil'
+      end
+
+      @tally = tally
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] recent_failures Value to be assigned
+    def recent_failures=(recent_failures)
+      if recent_failures.nil?
+        fail ArgumentError, 'recent_failures cannot be nil'
+      end
+
+      @recent_failures = recent_failures
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          total == o.total &&
+          tally == o.tally &&
+          buckets == o.buckets &&
+          recent_failures == o.recent_failures &&
+          next_scheduled == o.next_scheduled
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [total, tally, buckets, recent_failures, next_scheduled].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end

data/lib/smplkit/_generated/jobs/lib/smplkit_jobs_client/models/run_stat_bucket.rb

@@ -0,0 +1,193 @@
+=begin
+#smplkit Jobs API
+
+#Scheduled HTTP job execution API for smplkit.
+
+The version of the OpenAPI document: 0.1.0
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.22.0
+
+=end
+
+require 'date'
+require 'time'
+
+module SmplkitGeneratedClient::Jobs
+  # Run count for one time bucket.
+  class RunStatBucket < ApiModelBase
+    # Start of the bucket (UTC). Buckets are aligned to the epoch — e.g. `1h` buckets start on the hour.
+    attr_accessor :bucket
+
+    # Runs created within this bucket.
+    attr_accessor :count
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'bucket' => :'bucket',
+        :'count' => :'count'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'bucket' => :'Time',
+        :'count' => :'Integer'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `SmplkitGeneratedClient::Jobs::RunStatBucket` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `SmplkitGeneratedClient::Jobs::RunStatBucket`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'bucket')
+        self.bucket = attributes[:'bucket']
+      else
+        self.bucket = nil
+      end
+
+      if attributes.key?(:'count')
+        self.count = attributes[:'count']
+      else
+        self.count = nil
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @bucket.nil?
+        invalid_properties.push('invalid value for "bucket", bucket cannot be nil.')
+      end
+
+      if @count.nil?
+        invalid_properties.push('invalid value for "count", count cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @bucket.nil?
+      return false if @count.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] bucket Value to be assigned
+    def bucket=(bucket)
+      if bucket.nil?
+        fail ArgumentError, 'bucket cannot be nil'
+      end
+
+      @bucket = bucket
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] count Value to be assigned
+    def count=(count)
+      if count.nil?
+        fail ArgumentError, 'count cannot be nil'
+      end
+
+      @count = count
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          bucket == o.bucket &&
+          count == o.count
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [bucket, count].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end