temporalio 0.2.0 → 0.3.0

data/lib/temporalio/internal/worker/workflow_worker.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'temporalio/api/payload_visitor'
+require 'temporalio/error'
+require 'temporalio/internal/worker/workflow_instance'
+require 'temporalio/scoped_logger'
+require 'temporalio/workflow'
+require 'temporalio/workflow/definition'
+require 'timeout'
+
+module Temporalio
+  module Internal
+    module Worker
+      # Worker for handling workflow activations. Most activation work is delegated to the workflow executor.
+      class WorkflowWorker
+        def self.workflow_definitions(workflows)
+          workflows.each_with_object({}) do |workflow, hash|
+            # Load definition
+            defn = begin
+              if workflow.is_a?(Workflow::Definition::Info)
+                workflow
+              else
+                Workflow::Definition::Info.from_class(workflow)
+              end
+            rescue StandardError
+              raise ArgumentError, "Failed loading workflow #{workflow}"
+            end
+
+            # Confirm name not in use
+            raise ArgumentError, "Multiple workflows named #{defn.name || '<dynamic>'}" if hash.key?(defn.name)
+
+            hash[defn.name] = defn
+          end
+        end
+
+        def initialize(worker:, bridge_worker:, workflow_definitions:)
+          @executor = worker.options.workflow_executor
+
+          payload_codec = worker.options.client.data_converter.payload_codec
+          @workflow_payload_codec_thread_pool = worker.options.workflow_payload_codec_thread_pool
+          if !Fiber.current_scheduler && payload_codec && !@workflow_payload_codec_thread_pool
+            raise ArgumentError, 'Must have workflow payload codec thread pool if providing codec and not using fibers'
+          end
+
+          # If there is a payload codec, we need to build encoding and decoding visitors
+          if payload_codec
+            @payload_encoding_visitor = Api::PayloadVisitor.new(skip_search_attributes: true) do |payload_or_payloads|
+              apply_codec_on_payload_visit(payload_or_payloads) { |payloads| payload_codec.encode(payloads) }
+            end
+            @payload_decoding_visitor = Api::PayloadVisitor.new(skip_search_attributes: true) do |payload_or_payloads|
+              apply_codec_on_payload_visit(payload_or_payloads) { |payloads| payload_codec.decode(payloads) }
+            end
+          end
+
+          @state = State.new(
+            workflow_definitions:,
+            bridge_worker:,
+            logger: worker.options.logger,
+            metric_meter: worker.options.client.connection.options.runtime.metric_meter,
+            data_converter: worker.options.client.data_converter,
+            deadlock_timeout: worker.options.debug_mode ? nil : 2.0,
+            # TODO(cretz): Make this more performant for the default set?
+            illegal_calls: WorkflowInstance::IllegalCallTracer.frozen_validated_illegal_calls(
+              worker.options.illegal_workflow_calls || {}
+            ),
+            namespace: worker.options.client.namespace,
+            task_queue: worker.options.task_queue,
+            disable_eager_activity_execution: worker.options.disable_eager_activity_execution,
+            workflow_interceptors: worker._workflow_interceptors,
+            workflow_failure_exception_types: worker.options.workflow_failure_exception_types.map do |t|
+              unless t.is_a?(Class) && t < Exception
+                raise ArgumentError, 'All failure types must classes inheriting Exception'
+              end
+
+              t
+            end.freeze
+          )
+
+          # Validate worker
+          @executor._validate_worker(worker, @state)
+        end
+
+        def handle_activation(runner:, activation:, decoded:)
+          # Encode in background if not encoded but it needs to be
+          if @payload_encoding_visitor && !decoded
+            if Fiber.current_scheduler
+              Fiber.schedule { decode_activation(runner, activation) }
+            else
+              @workflow_payload_codec_thread_pool.execute { decode_activation(runner, activation) }
+            end
+          else
+            @executor._activate(activation, @state) do |activation_completion|
+              runner.apply_workflow_activation_complete(workflow_worker: self, activation_completion:, encoded: false)
+            end
+          end
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          # Should never happen, executors are expected to trap things
+          @state.logger.error("Failed issuing activation on workflow run ID: #{activation.run_id}")
+          @state.logger.error(e)
+        end
+
+        def handle_activation_complete(runner:, activation_completion:, encoded:, completion_complete_queue:)
+          if @payload_encoding_visitor && !encoded
+            if Fiber.current_scheduler
+              Fiber.schedule { encode_activation_completion(runner, activation_completion) }
+            else
+              @workflow_payload_codec_thread_pool.execute do
+                encode_activation_completion(runner, activation_completion)
+              end
+            end
+          else
+            @state.bridge_worker.async_complete_workflow_activation(
+              activation_completion.run_id, activation_completion.to_proto, completion_complete_queue
+            )
+          end
+        end
+
+        def on_shutdown_complete
+          @state.evict_all
+        end
+
+        private
+
+        def decode_activation(runner, activation)
+          @payload_decoding_visitor.run(activation)
+          runner.apply_workflow_activation_decoded(workflow_worker: self, activation:)
+        end
+
+        def encode_activation_completion(runner, activation_completion)
+          @payload_encoding_visitor.run(activation_completion)
+          runner.apply_workflow_activation_complete(workflow_worker: self, activation_completion:, encoded: true)
+        end
+
+        def apply_codec_on_payload_visit(payload_or_payloads, &)
+          case payload_or_payloads
+          when Temporalio::Api::Common::V1::Payload
+            new_payloads = yield [payload_or_payloads]
+            payload_or_payloads.metadata = new_payloads.first.metadata
+            payload_or_payloads.data = new_payloads.first.data
+          when Enumerable
+            payload_or_payloads.replace(yield payload_or_payloads) # steep:ignore
+          else
+            raise 'Unrecognized visitor type'
+          end
+        end
+
+        class State
+          attr_reader :workflow_definitions, :bridge_worker, :logger, :metric_meter, :data_converter, :deadlock_timeout,
+                      :illegal_calls, :namespace, :task_queue, :disable_eager_activity_execution,
+                      :workflow_interceptors, :workflow_failure_exception_types
+
+          def initialize(
+            workflow_definitions:, bridge_worker:, logger:, metric_meter:, data_converter:, deadlock_timeout:,
+            illegal_calls:, namespace:, task_queue:, disable_eager_activity_execution:,
+            workflow_interceptors:, workflow_failure_exception_types:
+          )
+            @workflow_definitions = workflow_definitions
+            @bridge_worker = bridge_worker
+            @logger = logger
+            @metric_meter = metric_meter
+            @data_converter = data_converter
+            @deadlock_timeout = deadlock_timeout
+            @illegal_calls = illegal_calls
+            @namespace = namespace
+            @task_queue = task_queue
+            @disable_eager_activity_execution = disable_eager_activity_execution
+            @workflow_interceptors = workflow_interceptors
+            @workflow_failure_exception_types = workflow_failure_exception_types
+
+            @running_workflows = {}
+            @running_workflows_mutex = Mutex.new
+          end
+
+          # This can never be called at the same time for the same run ID on the same state object
+          def get_or_create_running_workflow(run_id, &)
+            instance = @running_workflows_mutex.synchronize { @running_workflows[run_id] }
+            # If instance is not there, we create it out of lock then store it under lock
+            unless instance
+              instance = yield
+              @running_workflows_mutex.synchronize { @running_workflows[run_id] = instance }
+            end
+            instance
+          end
+
+          def evict_running_workflow(run_id)
+            @running_workflows_mutex.synchronize { @running_workflows.delete(run_id) }
+          end
+
+          def evict_all
+            @running_workflows_mutex.synchronize { @running_workflows.clear }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/metric.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'temporalio/internal/metric'
+
+module Temporalio
+  # Metric that can be recorded from a metric meter. This is obtained via {Meter.create_metric}. The metric meter is
+  # obtained via workflow environment, activity context, or from the {Runtime} if in neither of those. This class is
+  # effectively abstract and will fail if `initialize` is attempted.
+  class Metric
+    # @!visibility private
+    def initialize
+      raise NotImplementedError, 'Metric is abstract, implementations override initialize'
+    end
+
+    # Record a value for the metric. For counters, this adds to any existing. For histograms, this records into proper
+    # buckets. For gauges, this sets the value. The value type must match the expectation.
+    #
+    # @param value [Numeric] Value to record. For counters and duration-based histograms, this value cannot be negative.
+    # @param additional_attributes [Hash{String, Symbol => String, Integer, Float, Boolean}, nil] Additional attributes
+    #   on this specific record. For better performance for attribute reuse, users are encouraged to use
+    #   {with_additional_attributes} to make a copy of this metric with those attributes.
+    def record(value, additional_attributes: nil)
+      raise NotImplementedError
+    end
+
+    # Create a copy of this metric but with the given additional attributes. This is more performant than providing
+    # attributes on each {record} call.
+    #
+    # @param additional_attributes [Hash{String, Symbol => String, Integer, Float, Boolean}] Attributes to set on the
+    #   resulting metric.
+    # @return [Metric] Copy of this metric with the additional attributes.
+    def with_additional_attributes(additional_attributes)
+      raise NotImplementedError
+    end
+
+    # @return [:counter, :histogram, :gauge] Metric type.
+    def metric_type
+      raise NotImplementedError
+    end
+
+    # @return [String] Metric name.
+    def name
+      raise NotImplementedError
+    end
+
+    # @return [String, nil] Metric description.
+    def description
+      raise NotImplementedError
+    end
+
+    # @return [String, nil] Metric unit.
+    def unit
+      raise NotImplementedError
+    end
+
+    # @return [:integer, :float, :duration] Metric value type.
+    def value_type
+      raise NotImplementedError
+    end
+
+    # Meter for creating metrics to record values on. This is obtained via workflow environment, activity context, or
+    # from the {Runtime} if in neither of those. This class is effectively abstract and will fail if `initialize` is
+    # attempted.
+    class Meter
+      # @return [Meter] A no-op instance of {Meter}.
+      def self.null
+        Internal::Metric::NullMeter.instance
+      end
+
+      # @!visibility private
+      def initialize
+        raise NotImplementedError, 'Meter is abstract, implementations override initialize'
+      end
+
+      # Create a new metric. Only certain metric types are accepted and only value types can work with certain metric
+      # types.
+      #
+      # @param metric_type [:counter, :histogram, :gauge] Metric type. Counters can only have `:integer` value types,
+      #   histograms can have `:integer`, `:float`, or :duration` value types, and gauges can have `:integer` or
+      #   `:float` value types.
+      # @param name [String] Metric name.
+      # @param description [String, nil] Metric description.
+      # @param unit [String, nil] Metric unit.
+      # @param value_type [:integer, :float, :duration] Metric value type. `:integer` works for all metric types,
+      #   `:float` works for `:histogram` and `:gauge` metric types, and `:duration` only works for `:histogram` metric
+      #   types.
+      # @return [Metric] Created metric.
+      def create_metric(
+        metric_type,
+        name,
+        description: nil,
+        unit: nil,
+        value_type: :integer
+      )
+        raise NotImplementedError
+      end
+
+      # Create a copy of this meter but with the given additional attributes. This is more performant than providing
+      # attributes on each {record} call.
+      #
+      # @param additional_attributes [Hash{String, Symbol => String, Integer, Float, Boolean}] Attributes to set on the
+      #   resulting meter.
+      # @return [Meter] Copy of this meter with the additional attributes.
+      def with_additional_attributes(additional_attributes)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/temporalio/retry_policy.rb

@@ -3,6 +3,14 @@
 require 'temporalio/internal/proto_utils'
 
 module Temporalio
+  RetryPolicy = Data.define(
+    :initial_interval,
+    :backoff_coefficient,
+    :max_interval,
+    :max_attempts,
+    :non_retryable_error_types
+  )
+
   # Options for retrying workflows and activities.
   #
   # @!attribute initial_interval
@@ -15,24 +23,39 @@ module Temporalio
   #   @return [Integer] Maximum number of attempts. If `0`, the default, there is no maximum.
   # @!attribute non_retryable_error_types
   #   @return [Array<String>, nil] List of error types that are not retryable.
-  RetryPolicy = Struct.new(
-    :initial_interval,
-    :backoff_coefficient,
-    :max_interval,
-    :max_attempts,
-    :non_retryable_error_types,
-    keyword_init: true
-  ) do
-    def initialize(*, **kwargs)
-      kwargs[:initial_interval] = 1.0 unless kwargs.key?(:initial_interval)
-      kwargs[:backoff_coefficient] = 2.0 unless kwargs.key?(:backoff_coefficient)
-      kwargs[:max_attempts] = 0 unless kwargs.key?(:max_attempts)
+  class RetryPolicy
+    # @!visibility private
+    def self._from_proto(raw_policy)
+      RetryPolicy.new(
+        initial_interval: Internal::ProtoUtils.duration_to_seconds(raw_policy.initial_interval) || raise, # Never nil
+        backoff_coefficient: raw_policy.backoff_coefficient,
+        max_interval: Internal::ProtoUtils.duration_to_seconds(raw_policy.maximum_interval),
+        max_attempts: raw_policy.maximum_attempts,
+        non_retryable_error_types: raw_policy.non_retryable_error_types&.to_a
+      )
+    end
+
+    # Create retry policy.
+    #
+    # @param initial_interval [Float] Backoff interval in seconds for the first retry. Default 1.0.
+    # @param backoff_coefficient [Float] Coefficient to multiply previous backoff interval by to get new interval.
+    #   Default 2.0.
+    # @param max_interval [Float, nil] Maximum backoff interval in seconds between retries. Default 100x
+    #   `initial_interval`.
+    # @param max_attempts [Integer] Maximum number of attempts. If `0`, the default, there is no maximum.
+    # @param non_retryable_error_types [Array<String>, nil] List of error types that are not retryable.
+    def initialize(
+      initial_interval: 1.0,
+      backoff_coefficient: 2.0,
+      max_interval: nil,
+      max_attempts: 0,
+      non_retryable_error_types: nil
+    )
       super
     end
 
     # @!visibility private
-    def to_proto
-      # @type self: RetryPolicy
+    def _to_proto
       raise 'Initial interval cannot be negative' if initial_interval.negative?
       raise 'Backoff coefficient cannot be less than 1' if backoff_coefficient < 1
       raise 'Max interval cannot be negative' if max_interval&.negative?

data/lib/temporalio/runtime.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
+require 'temporalio/internal/bridge'
 require 'temporalio/internal/bridge/runtime'
+require 'temporalio/internal/metric'
+require 'temporalio/metric'
 
 module Temporalio
   # Runtime for Temporal Ruby SDK.
@@ -9,6 +12,11 @@ module Temporalio
   # before any clients are created, and set it via {default=}. Every time a new runtime is created, a new internal Rust
   # thread pool is created.
   class Runtime
+    TelemetryOptions = Data.define(
+      :logging,
+      :metrics
+    )
+
     # Telemetry options for the runtime.
     #
     # @!attribute logging
@@ -16,15 +24,13 @@ module Temporalio
     #     to nil to disable logging.
     # @!attribute metrics
     #   @return [MetricsOptions, nil] Metrics options.
-    TelemetryOptions = Struct.new(
-      :logging,
-      :metrics,
-      keyword_init: true
-    ) do
-      # @!visibility private
-      def initialize(**kwargs)
-        # @type var kwargs: untyped
-        kwargs[:logging] = LoggingOptions.new unless kwargs.key?(:logging)
+    class TelemetryOptions
+      # Create telemetry options.
+      #
+      # @param logging [LoggingOptions, nil] Logging options, default is new {LoggingOptions} with no parameters. Can be
+      #   set to nil to disable logging.
+      # @param metrics [MetricsOptions, nil] Metrics options.
+      def initialize(logging: LoggingOptions.new, metrics: nil)
         super
       end
 
@@ -38,20 +44,21 @@ module Temporalio
       end
     end
 
+    LoggingOptions = Data.define(
+      :log_filter
+      # TODO(cretz): forward_to
+    )
+
     # Logging options for runtime telemetry.
     #
     # @!attribute log_filter
     #   @return [LoggingFilterOptions, String] Logging filter for Core, default is new {LoggingFilterOptions} with no
     #     parameters.
-    LoggingOptions = Struct.new(
-      :log_filter,
-      # TODO(cretz): forward_to
-      keyword_init: true
-    ) do
-      # @!visibility private
-      def initialize(**kwargs)
-        # @type var kwargs: untyped
-        kwargs[:log_filter] = LoggingFilterOptions.new unless kwargs.key?(:log_filter)
+    class LoggingOptions
+      # Create logging options
+      #
+      # @param log_filter [LoggingFilterOptions, String] Logging filter for Core.
+      def initialize(log_filter: LoggingFilterOptions.new)
         super
       end
 
@@ -70,22 +77,23 @@ module Temporalio
       end
     end
 
+    LoggingFilterOptions = Data.define(
+      :core_level,
+      :other_level
+    )
+
     # Logging filter options for Core.
     #
     # @!attribute core_level
-    #   @return ['TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR'] Log level for Core log messages, default is +'WARN'+.
+    #   @return ['TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR'] Log level for Core log messages.
     # @!attribute other_level
-    #   @return ['TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR'] Log level for other Rust log messages, default is +'WARN'+.
-    LoggingFilterOptions = Struct.new(
-      :core_level,
-      :other_level,
-      keyword_init: true
-    ) do
-      # @!visibility private
-      def initialize(**kwargs)
-        # @type var kwargs: untyped
-        kwargs[:core_level] = 'WARN' unless kwargs.key?(:core_level)
-        kwargs[:other_level] = 'ERROR' unless kwargs.key?(:other_level)
+    #   @return ['TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR'] Log level for other Rust log messages.
+    class LoggingFilterOptions
+      # Create logging filter options.
+      #
+      # @param core_level ['TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR'] Log level for Core log messages.
+      # @!attribute other_level ['TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR'] Log level for other Rust log messages.
+      def initialize(core_level: 'WARN', other_level: 'ERROR')
         super
       end
 
@@ -96,6 +104,14 @@ module Temporalio
       end
     end
 
+    MetricsOptions = Data.define(
+      :opentelemetry,
+      :prometheus,
+      :attach_service_name,
+      :global_tags,
+      :metric_prefix
+    )
+
     # Metrics options for runtime telemetry. Either {opentelemetry} or {prometheus} required, but not both.
     #
     # @!attribute opentelemetry
@@ -105,23 +121,28 @@ module Temporalio
     #   @return [PrometheusMetricsOptions, nil] Prometheus options if using Prometheus. This is mutually exclusive with
     #     +opentelemetry+.
     # @!attribute attach_service_name
-    #   @return [Boolean] Whether to put the service_name on every metric, default +true+.
+    #   @return [Boolean] Whether to put the service_name on every metric.
     # @!attribute global_tags
     #   @return [Hash<String, String>, nil] Resource tags to be applied to all metrics.
     # @!attribute metric_prefix
-    #   @return [String, nil] Prefix to put on every Temporal metric. If unset, defaults to +temporal_+.
-    MetricsOptions = Struct.new(
-      :opentelemetry,
-      :prometheus,
-      :attach_service_name,
-      :global_tags,
-      :metric_prefix,
-      keyword_init: true
-    ) do
-      # @!visibility private
-      def initialize(**kwargs)
-        # @type var kwargs: untyped
-        kwargs[:attach_service_name] = true unless kwargs.key?(:attach_service_name)
+    #   @return [String, nil] Prefix to put on every Temporal metric. If unset, defaults to `temporal_`.
+    class MetricsOptions
+      # Create metrics options. Either `opentelemetry` or `prometheus` required, but not both.
+      #
+      # @param opentelemetry [OpenTelemetryMetricsOptions, nil] OpenTelemetry options if using OpenTelemetry. This is
+      #   mutually exclusive with `prometheus`.
+      # @param prometheus [PrometheusMetricsOptions, nil] Prometheus options if using Prometheus. This is mutually
+      #   exclusive with `opentelemetry`.
+      # @param attach_service_name [Boolean] Whether to put the service_name on every metric.
+      # @param global_tags [Hash<String, String>, nil] Resource tags to be applied to all metrics.
+      # @param metric_prefix [String, nil] Prefix to put on every Temporal metric. If unset, defaults to `temporal_`.
+      def initialize(
+        opentelemetry: nil,
+        prometheus: nil,
+        attach_service_name: true,
+        global_tags: nil,
+        metric_prefix: nil
+      )
         super
       end
 
@@ -138,6 +159,14 @@ module Temporalio
       end
     end
 
+    OpenTelemetryMetricsOptions = Data.define(
+      :url,
+      :headers,
+      :metric_periodicity,
+      :metric_temporality,
+      :durations_as_seconds
+    )
+
     # Options for exporting metrics to OpenTelemetry.
     #
     # @!attribute url
@@ -152,25 +181,28 @@ module Temporalio
     # @!attribute durations_as_seconds
     #   @return [Boolean] Whether to use float seconds instead of integer milliseconds for durations, default is
     #     +false+.
-    OpenTelemetryMetricsOptions = Struct.new(
-      :url,
-      :headers,
-      :metric_periodicity,
-      :metric_temporality,
-      :durations_as_seconds,
-      keyword_init: true
-    ) do
+    class OpenTelemetryMetricsOptions
       # OpenTelemetry metric temporality.
-      module MetricTemporality # rubocop:disable Lint/ConstantDefinitionInBlock
+      module MetricTemporality
         CUMULATIVE = 1
         DELTA = 2
       end
 
-      # @!visibility private
-      def initialize(**kwargs)
-        # @type var kwargs: untyped
-        kwargs[:metric_temporality] = MetricTemporality::CUMULATIVE unless kwargs.key?(:metric_temporality)
-        kwargs[:durations_as_seconds] = false unless kwargs.key?(:durations_as_seconds)
+      # Create OpenTelemetry options.
+      #
+      # @param url [String] URL for OpenTelemetry endpoint.
+      # @param headers [Hash<String, String>, nil] Headers for OpenTelemetry endpoint.
+      # @param metric_periodicity [Float, nil] How frequently metrics should be exported, unset uses internal default.
+      # @param metric_temporality [MetricTemporality] How frequently metrics should be exported.
+      # @param durations_as_seconds [Boolean] Whether to use float seconds instead of integer milliseconds for
+      #   durations.
+      def initialize(
+        url:,
+        headers: nil,
+        metric_periodicity: nil,
+        metric_temporality: MetricTemporality::CUMULATIVE,
+        durations_as_seconds: false
+      )
         super
       end
 
@@ -191,30 +223,37 @@ module Temporalio
       end
     end
 
+    PrometheusMetricsOptions = Data.define(
+      :bind_address,
+      :counters_total_suffix,
+      :unit_suffix,
+      :durations_as_seconds
+    )
+
     # Options for exporting metrics to Prometheus.
     #
     # @!attribute bind_address
     #   @return [String] Address to bind to for Prometheus endpoint.
     # @!attribute counters_total_suffix
-    #   @return [Boolean] If +true+, all counters will include a +_total+ suffix, default is +false+.
+    #   @return [Boolean] If `true`, all counters will include a `_total` suffix.
     # @!attribute unit_suffix
-    #   @return [Boolean] If +true+, all histograms will include the unit in their name as a suffix, default is +false+.
+    #   @return [Boolean] If `true`, all histograms will include the unit in their name as a suffix.
     # @!attribute durations_as_seconds
-    #   @return [Boolean] Whether to use float seconds instead of integer milliseconds for durations, default is
-    #     +false+.
-    PrometheusMetricsOptions = Struct.new(
-      :bind_address,
-      :counters_total_suffix,
-      :unit_suffix,
-      :durations_as_seconds,
-      keyword_init: true
-    ) do
-      # @!visibility private
-      def initialize(**kwargs)
-        # @type var kwargs: untyped
-        kwargs[:counters_total_suffix] = false unless kwargs.key?(:counters_total_suffix)
-        kwargs[:unit_suffix] = false unless kwargs.key?(:unit_suffix)
-        kwargs[:durations_as_seconds] = false unless kwargs.key?(:durations_as_seconds)
+    #   @return [Boolean] Whether to use float seconds instead of integer milliseconds for durations.
+    class PrometheusMetricsOptions
+      # Create Prometheus options.
+      #
+      # @param bind_address [String] Address to bind to for Prometheus endpoint.
+      # @param counters_total_suffix [Boolean] If `true`, all counters will include a `_total` suffix.
+      # @param unit_suffix [Boolean] If `true`, all histograms will include the unit in their name as a suffix.
+      # @param durations_as_seconds [Boolean] Whether to use float seconds instead of integer milliseconds for
+      #   durations.
+      def initialize(
+        bind_address:,
+        counters_total_suffix: false,
+        unit_suffix: false,
+        durations_as_seconds: false
+      )
         super
       end
 
@@ -248,6 +287,9 @@ module Temporalio
       @default = runtime
     end
 
+    # @return [Metric::Meter] Metric meter that can create and record metric values.
+    attr_reader :metric_meter
+
     # Create new Runtime. For most users, this should only be done once globally. In addition to creating a Rust thread
     # pool, this also consumes a Ruby thread for its lifetime.
     #
@@ -256,6 +298,7 @@ module Temporalio
       @core_runtime = Internal::Bridge::Runtime.new(
         Internal::Bridge::Runtime::Options.new(telemetry: telemetry._to_bridge)
       )
+      @metric_meter = Internal::Metric::Meter.create_from_runtime(self) || Metric::Meter.null
       # We need a thread to run the command loop
       # TODO(cretz): Is this something users should be concerned about or need control over?
       Thread.new do