Yabeda

https://github.com/yabeda-rb/yabeda
Admin
Yabeda is an extensible Ruby monitoring framework for collecting application metrics and exporting...
Tokens:26,684
Snippets:366
Trust Score:9.4
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Metric Configuration Examples

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/quick-reference.md

Examples of various configuration options available when defining metrics.

```ruby
counter :events
```

```ruby
comment: "Total events"
```

```ruby
tags: [:method, :status]
```

```ruby
unit: :seconds
```

```ruby
per: :second
```

```ruby
group: :api
```

```ruby
adapter: :prometheus
```

```ruby
aggregation: :sum
```

```ruby
buckets: [0.01, 0.1, 1, 10]
```

--------------------------------

### Identify manual test setup conflict

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/errors.md

Example of a conflict caused by calling configure! in both before(:all) and before(:each) blocks.

```ruby
describe "my feature" do
  before(:all) do
    Yabeda.configure do
      counter :foo
    end
    Yabeda.configure!
  end
  
  before(:each) do
    Yabeda.configure!  # Already configured!
  end
end
```

--------------------------------

### Counter configuration and usage

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-metric-classes.md

Example showing how to define a counter and perform various increment operations.

```ruby
Yabeda.configure do
  group :app do
    counter :events_total, tags: [:event_type]
  end
end

# Increment by 1 (default)
Yabeda.app.events_total.increment({event_type: 'click'})

# Increment by specific amount
Yabeda.app.events_total.increment({event_type: 'click'}, by: 5)

# Shorthand: only by value
Yabeda.app.events_total.increment(by: 3)

# Get current value
current = Yabeda.app.events_total.get({event_type: 'click'})
```

--------------------------------

### Gauge configuration and set usage

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-metric-classes.md

Example showing how to define a gauge and set its value.

```ruby
Yabeda.configure do
  group :system do
    gauge :memory_usage_mb, tags: [:process]
  end
end

Yabeda.system.memory_usage_mb.set({process: 'worker'}, 256)
```

--------------------------------

### Install Yabeda Gem

Source: https://github.com/yabeda-rb/yabeda/blob/master/README.md

Add the gem to your Gemfile to begin collecting metrics.

```ruby
gem 'yabeda'

# Add some plugins to quickly start collecting some essential metrics:
# gem 'yabeda-rails'
# gem 'yabeda-sidekiq'

# Then add monitoring system adapter, e.g.:
# gem 'yabeda-prometheus'
```

--------------------------------

### Identify configuration conflict in RSpec

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/errors.md

Example of a common configuration conflict between RSpec setup and application initializers.

```ruby
# spec_helper.rb
require "yabeda/rspec"
# RSpec automatically calls Yabeda.configure! in before(:suite)

# app/initializers/yabeda.rb
Yabeda.configure do
  # ...
end
Yabeda.configure!  # This raises AlreadyConfiguredError
```

--------------------------------

### Resolve test setup conflict

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/errors.md

Guarding the configuration call within a test setup block.

```ruby
before(:each) do
  Yabeda.configure! unless Yabeda.already_configured?
end
```

--------------------------------

### Gauge increment usage

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-metric-classes.md

Example showing how to increment a gauge value.

```ruby
Yabeda.system.memory_usage_mb.increment({process: 'worker'}, by: 50)
```

--------------------------------

### Tag Matching Behavior Example

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-rspec.md

Demonstrates how with_tags performs partial matching against recorded tags.

```ruby
Yabeda.myapp.requests.increment({method: 'GET', status: 200, user_id: '123'})

expect { subject }.to increment_yabeda_counter(Yabeda.myapp.requests)
  .with_tags(method: 'GET', status: 200)  # Matches: user_id is ignored
```

--------------------------------

### Handle ConfigurationError

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/errors.md

Example of rescuing a ConfigurationError during the Yabeda configuration phase.

```ruby
begin
  Yabeda.configure do
    counter :foo, adapter: :unknown
  end
  Yabeda.configure!
rescue Yabeda::ConfigurationError => e
  puts "Configuration error: #{e.message}"
  # => Configuration error: invalid adapter option :unknown in metric <Counter: foo>
end
```

--------------------------------

### Gauge decrement usage

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-metric-classes.md

Example showing how to decrement a gauge value.

```ruby
Yabeda.system.memory_usage_mb.decrement({process: 'worker'}, by: 10)
```

--------------------------------

### update_yabeda_gauge Usage Examples

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-rspec.md

Common patterns for verifying gauge updates, including specific values, ranges, and tag-based scoping.

```ruby
# Gauge was updated
expect { subject }.to update_yabeda_gauge(Yabeda.system.memory)

# Gauge set to specific value
expect { subject }.to update_yabeda_gauge(Yabeda.system.memory).to(2048)

# Gauge value within range
expect { subject }.to update_yabeda_gauge(Yabeda.system.memory)
  .to(be_between(1000, 5000))

# Update scoped to tags
expect { subject }.to update_yabeda_gauge(Yabeda.system.active_connections)
  .with_tags(database: 'production')

# Multiple tag sets with different values
expect { subject }.to update_yabeda_gauge(Yabeda.system.process_memory).with(
  { type: 'heap' } => 1024,
  { type: 'rss' } => be > 2048
)

# Gauge was NOT updated
expect { subject }.not_to update_yabeda_gauge(Yabeda.system.memory)
```

--------------------------------

### Initialize Adapter Instances

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/types.md

Adapters implement the Yabeda::BaseAdapter interface to handle metric reporting to external systems.

```ruby
# Base class for all adapters
adapter = Yabeda::NullAdapter.new

# Subclasses vary by monitoring system
# Examples: PrometheusAdapter, DatadogAdapter, NewRelicAdapter
```

--------------------------------

### Handle AlreadyConfiguredError

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/quick-reference.md

Avoid calling configure! multiple times. Use already_configured? to check status before initialization.

```ruby
Yabeda.configure!
Yabeda.configure!  # Error!
```

```ruby
Yabeda.configure! unless Yabeda.already_configured?
```

--------------------------------

### Configure Yabeda via environment variables

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/configuration.md

Set global configuration options using environment variables prefixed with YABEDA_.

```bash
export YABEDA_DEBUG=true
ruby myapp.rb
```

--------------------------------

### Yabeda.configure!

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Finalizes the configuration process by evaluating all queued blocks and registering metrics with adapters.

```APIDOC
## Yabeda.configure!

### Description
Finalizes configuration by evaluating all queued configuration blocks and registering metrics with their adapters. Must be called once before metrics can be used.

### Returns
- nil

### Errors
- Yabeda::AlreadyConfiguredError - Raised if called more than once.
```

--------------------------------

### increment_yabeda_counter Usage Examples

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-rspec.md

Various ways to use the increment_yabeda_counter matcher in RSpec tests.

```ruby
# Basic: counter was incremented
expect { subject }.to increment_yabeda_counter(Yabeda.myapp.requests)

# Counter was incremented by specific amount
expect { subject }.to increment_yabeda_counter(Yabeda.myapp.requests).by(3)

# Increment scoped to tags
expect { subject }.to increment_yabeda_counter(Yabeda.myapp.requests)
  .with_tags(method: "GET", status: 200)

# Multiple tag sets with matchers
expect { subject }.to increment_yabeda_counter(Yabeda.myapp.requests).with(
  { method: "GET" } => 5,
  { method: "POST" } => be >= 2
)

# Counter was NOT incremented
expect { subject }.not_to increment_yabeda_counter(Yabeda.myapp.requests)

# Using counter name string instead of instance
expect { subject }.to increment_yabeda_counter('myapp_requests').by(1)
```

--------------------------------

### Register Adapter Before Configuration

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/errors.md

Demonstrates the incorrect way to use an unregistered adapter versus the correct registration pattern.

```ruby
# Wrong - adapter not registered
Yabeda.configure do
  group :api do
    adapter :my_custom_adapter
    counter :events
  end
end
```

```ruby
require 'yabeda'
require 'my_custom_adapter'

# Register adapter
Yabeda.register_adapter(:my_custom_adapter, MyCustomAdapter.new)

Yabeda.configure do
  group :api do
    adapter :my_custom_adapter
    counter :events
  end
end

Yabeda.configure!
```

--------------------------------

### Implement Multi-Tenant Metrics

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/tags-system.md

Sets a default tenant ID tag and demonstrates how to scope metric increments to a specific tenant.

```ruby
Yabeda.configure do
  default_tag :tenant_id, ''
  
  group :app do
    counter :api_calls, tags: [:endpoint]
  end
end

# In application code
def handle_request(tenant)
  Yabeda.with_tags(tenant_id: tenant.id.to_s) do
    Yabeda.app.api_calls.increment({endpoint: '/users'})
  end
end
```

--------------------------------

### Using the TestAdapter

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-adapters.md

A singleton adapter that stores metric values in memory for inspection during testing.

```ruby
require 'yabeda'
require 'yabeda/testing'

Yabeda.configure do
  group :myapp do
    counter :requests
    gauge :memory
  end
end

Yabeda.configure!

# Access test adapter
adapter = Yabeda::TestAdapter.instance

# Record metrics
Yabeda.myapp.requests.increment({})
Yabeda.myapp.memory.set({}, 256)

# Inspect values
adapter.counters        # => {metric => {tags => value}}
adapter.gauges          # => {metric => {tags => value}}
adapter.histograms      # => {metric => {tags => value}}
adapter.summaries       # => {metric => {tags => value}}

# Reset for next test
adapter.reset!
```

--------------------------------

### Registering a Custom Adapter

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-adapters.md

Implement Yabeda::BaseAdapter and register the instance to receive metric events.

```ruby
class MyAdapter < Yabeda::BaseAdapter
  # Implement required methods
end

# Register the adapter
adapter_instance = MyAdapter.new
Yabeda.register_adapter(:my_adapter, adapter_instance)

# Now metrics can be configured to use it
Yabeda.configure do
  group :myapp do
    adapter :my_adapter
    counter :events
  end
end
```

--------------------------------

### Configure metric settings for individual adapters

Source: https://github.com/yabeda-rb/yabeda/blob/master/README.md

Define custom bucket configurations for specific adapters like Prometheus within a metric definition.

```rb
histogram :foo, comment: "say what?" do
  adapter :prometheus do
    buckets [0.01, 0.5, …, 60, 300, 3600]
  end
end
```

--------------------------------

### Handle AlreadyConfiguredError

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/errors.md

Demonstrates catching the error when attempting to configure Yabeda multiple times.

```ruby
Yabeda.configure do
  counter :foo
end

Yabeda.configure!

begin
  Yabeda.configure!
rescue Yabeda::AlreadyConfiguredError => e
  puts e.message
  # => Yabeda was already configured in path/to/file.rb:123:in `<main>'
end
```

--------------------------------

### Handle unknown adapter error

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/quick-reference.md

Ensure the adapter gem is registered before attempting to reference it in the configuration block.

```ruby
Yabeda.configure do
  group :api do
    adapter :prometheus  # Not registered yet!
  end
end
```

--------------------------------

### Access Group Instances

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/types.md

Groups organize metrics and manage configuration like default tags and adapter restrictions.

```ruby
# Represents a group of metrics
group = Yabeda.groups[:api]  # => Yabeda::Group instance
group = Yabeda.groups[nil]   # => Yabeda::GlobalGroup instance (global metrics)
```

--------------------------------

### Using the NullAdapter

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-adapters.md

A no-op adapter that discards all metrics, suitable for development environments.

```ruby
require 'yabeda'

# Automatically registered as :null_adapter
Yabeda.configure do
  counter :events
end

Yabeda.configure!

# Metrics are recorded but not exported
Yabeda.events.increment({})
```

--------------------------------

### Recording summary observations

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-metric-classes.md

Demonstrates configuring a summary and recording observations via blocks or direct numeric input.

```ruby
Yabeda.configure do
  group :database do
    summary :query_duration, unit: :seconds, tags: [:query_type]
  end
end

# Observe a block
Yabeda.database.query_duration.observe({query_type: 'select'}) do
  User.find(1)
end

# Record a pre-calculated value
Yabeda.database.query_duration.observe({query_type: 'update'}, 0.156)
```

--------------------------------

### Create annotated release tag

Source: https://github.com/yabeda-rb/yabeda/blob/master/README.md

Create a signed, annotated git tag for the current version.

```sh
git tag v${version} --annotate --message="${version}: " --edit --sign
```

--------------------------------

### Create and Register a Custom Yabeda Adapter

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-adapters.md

Inherit from Yabeda::BaseAdapter to implement metric registration and reporting methods. Register the instance using Yabeda.register_adapter to make it available to the application.

```ruby
class DatadogAdapter < Yabeda::BaseAdapter
  def initialize(api_key)
    @client = Datadog::Client.new(api_key)
  end
  
  def register_counter!(metric)
    # Register counter with Datadog API
  end
  
  def perform_counter_increment!(counter, tags, increment)
    @client.increment(counter.name, tags, increment)
  end
  
  def register_gauge!(metric)
    # Register gauge with Datadog API
  end
  
  def perform_gauge_set!(gauge, tags, value)
    @client.gauge(gauge.name, tags, value)
  end
  
  # Implement other metric types...
  
  def debug!
    @client.enable_debug_logging
  end
end

# Usage
adapter = DatadogAdapter.new(ENV['DATADOG_API_KEY'])
Yabeda.register_adapter(:datadog, adapter)
```

--------------------------------

### Apply Configuration

Source: https://github.com/yabeda-rb/yabeda/blob/master/README.md

Finalize the Yabeda configuration after all metrics have been declared.

```ruby
Yabeda.configure!
```

--------------------------------

### Configure adapter scoping

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Limits metric or group registration to specific adapters. Metrics not included in the specified adapters will use the null adapter.

```ruby
Yabeda.adapter(*adapter_names, group: nil, &block)
```

```ruby
Yabeda.configure do
  group :internal do
    adapter :prometheus
    counter :internal_events
    gauge :internal_state
  end
  
  group :external do
    adapter :datadog, :newrelic
    counter :external_events
  end
  
  adapter :prometheus do
    include_group :internal
  end
end
```

--------------------------------

### Implement Environment Segmentation

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/tags-system.md

Configures global default tags for environment and region using system environment variables.

```ruby
Yabeda.configure do
  default_tag :environment, ENV['RAILS_ENV'] || 'development'
  default_tag :region, ENV['AWS_REGION'] || 'us-east-1'
  
  group :production_metrics do
    counter :deployments
    gauge :active_instances
  end
end
```

--------------------------------

### Correct Metric Options

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/errors.md

Illustrates the error caused by using unsupported options for a metric type and the correct usage.

```ruby
# Wrong - Gauge doesn't support 'buckets' option
Yabeda.configure do
  gauge :my_gauge, buckets: [1, 5, 10]
end
Yabeda.configure!
# => ConfigurationError: option 'buckets' is not available for Gauge
```

```ruby
Yabeda.configure do
  # 'buckets' is valid for Histogram
  histogram :my_histogram, buckets: [1, 5, 10]
end
```

--------------------------------

### perform_summary_observe!

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-adapters.md

Records an observation for a summary. Must be implemented by adapters that support summaries.

```APIDOC
## perform_summary_observe!(summary, tags, value)

### Description
Called when a summary observation is recorded. Must be implemented by adapters that support summaries.

### Parameters
- **summary** (Yabeda::Summary) - Required - Summary being observed
- **tags** (Hash<Symbol => String>) - Required - Merged tag values
- **value** (Float) - Required - Observed value

### Returns
- nil

### Raises
- NotImplementedError — if adapter doesn't support summaries
```

--------------------------------

### register_summary!

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-adapters.md

Registers a summary metric within the adapter. Must be implemented by adapters that support summaries.

```APIDOC
## register_summary!(metric)

### Description
Called when a summary metric is registered. Must be implemented by adapters that support summaries.

### Parameters
- **metric** (Yabeda::Summary) - Required - Summary to register

### Returns
- nil

### Raises
- NotImplementedError — if adapter doesn't support summaries
```

--------------------------------

### group.adapter(*adapter_names)

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-group.md

Configures or queries the adapters registered for the group.

```APIDOC
## group.adapter(*adapter_names)

### Description
Registers specific adapters for this group, or returns the currently registered adapters if no arguments are provided.

### Parameters
- **adapter_names** (Array<Symbol>) - Optional - Adapter names to register
```

--------------------------------

### Register and assign adapters

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/configuration.md

Register adapter instances and assign them to specific metric groups within the configuration block.

```ruby
# Prometheus adapter (if yabeda-prometheus is installed)
Yabeda.register_adapter(:prometheus, PrometheusAdapter.instance)

Yabeda.configure do
  group :myapp do
    adapter :prometheus  # Use Prometheus adapter for this group
    counter :events
  end
  
  # Multiple adapters for the same group
  group :tracking do
    adapter :prometheus, :datadog
    counter :user_actions
  end
end
```

--------------------------------

### Summary observe method signatures

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-metric-classes.md

Defines the method signatures for recording observations in a summary.

```ruby
summary.observe(tags = {}, value = nil) { block }
summary.observe(tags = {}, value)
```

--------------------------------

### Yabeda.reset!

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Clears all configuration, metrics, adapters, and collectors. Intended for testing purposes.

```APIDOC
## Yabeda.reset!

### Description
Clears all configuration, metrics, adapters, and collectors. Intended for testing purposes. Does not rollback changes in adapters themselves.

### Returns
nil
```

--------------------------------

### Yabeda.configure

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Registers a configuration block for metric and collector definitions. If called before Yabeda.configure!, the block is queued; otherwise, it executes immediately.

```APIDOC
## Yabeda.configure(&block)

### Description
Registers a configuration block for deferred or immediate execution. If called before Yabeda.configure!, the block is queued for later execution. If called after configuration is complete, the block executes immediately.

### Parameters
- **block** (Proc) - Required - Block containing metric and collector definitions

### Returns
- nil
```

--------------------------------

### Commit version changes

Source: https://github.com/yabeda-rb/yabeda/blob/master/README.md

Stage version and changelog files, then create a commit with the current gem version.

```sh
git add lib/yabeda/version.rb CHANGELOG.md
version=$(ruby -r ./lib/yabeda/version.rb -e "puts Gem::Version.new(Yabeda::VERSION)")
git commit --message="${version}: " --edit
```

--------------------------------

### Configure Tag Precedence

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/tags-system.md

Demonstrates how global, group, thread-local, and explicit tags interact and override each other.

```ruby
Yabeda.configure do
  # Global default tag
  default_tag :environment, 'production'
  default_tag :service, 'unknown'  # Will be overridden
  
  group :api do
    # Group default tags
    default_tag :service, 'api-service'
    default_tag :component, 'http'
    
    counter :requests, tags: [:method]
  end
end

Yabeda.configure!

# Example 1: Just explicit tags
Yabeda.api.requests.increment({method: 'GET'})
# Results in: environment=production, service=api-service, component=http, method=GET

# Example 2: Override with thread-local tags
Yabeda.with_tags(environment: 'staging', service: 'api-debug') do
  Yabeda.api.requests.increment({method: 'POST'})
end
# Results in: environment=staging, service=api-debug, component=http, method=POST
# (thread-local tags override both global and group defaults)

# Example 3: Explicit tags override everything
Yabeda.with_tags(environment: 'staging') do
  Yabeda.api.requests.increment({method: 'DELETE', environment: 'production'})
end
# Results in: environment=production, service=api-service, component=http, method=DELETE
# (explicit environment tag wins)
```

--------------------------------

### Allowlist metrics with only

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Creates an allowlist for metrics within a group. Metrics not listed are silenced.

```ruby
Yabeda.only(*metric_names, group: nil)
```

```ruby
Yabeda.configure do
  group :activerecord do
    only :queries_total, :connection_pool_size
    
    counter :queries_total
    gauge :connection_pool_size
    counter :query_duration  # This will be silenced
  end
end
```

--------------------------------

### Enable Yabeda Debug Mode

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/quick-reference.md

Use environment variables or programmatic calls to monitor Yabeda's internal performance metrics.

```ruby
# Via environment variable
YABEDA_DEBUG=true bundle exec rails server

# Or programmatically
Yabeda.debug!

# Access debug metrics
Yabeda.yabeda.collect_duration  # Histogram of collector block times
```

--------------------------------

### Configure Yabeda in Rails

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/errors.md

Define metrics within a Rails initializer. Rails automatically invokes the configuration, so manual calls are typically not required.

```ruby
# config/initializers/yabeda.rb
Yabeda.configure do
  group :rails do
    counter :requests
  end
end

# No need to call Yabeda.configure! - Rails handles it
```

--------------------------------

### Register Adapters

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/quick-reference.md

Register metric adapters to enable reporting to external systems.

```ruby
# Prometheus
Yabeda.register_adapter(:prometheus, PrometheusAdapter.instance)

# Datadog
Yabeda.register_adapter(:datadog, DatadogAdapter.new(api_key))
```

--------------------------------

### Accessing Configuration Object

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/types.md

Provides access to the Yabeda configuration object, which inherits from Anyway::Config and manages environment variables.

```ruby
# Type: Yabeda::Config (inherits from Anyway::Config)
config = Yabeda.config
config.debug  # => true / false (from YABEDA_DEBUG env var or defaults)
```

--------------------------------

### Instantiate a Metric

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-metric-classes.md

Constructor for the base Metric class. Metrics are typically created via the Yabeda DSL rather than direct instantiation.

```ruby
Yabeda::Metric.new(name, comment: nil, tags: nil, unit: nil, per: nil, 
                          group: nil, aggregation: nil, adapter: nil)
```

--------------------------------

### Declare Metrics

Source: https://github.com/yabeda-rb/yabeda/blob/master/README.md

Define counters, gauges, histograms, and summaries within a configuration block.

```ruby
Yabeda.configure do
  group :your_app do
    counter   :bells_rang_count, comment: "Total number of bells being rang", tags: %i[bell_size]
    gauge     :whistles_active,  comment: "Number of whistles ready to whistle"
    histogram :whistle_runtime do
      comment "How long whistles are being active"
      unit :seconds
    end
    summary :bells_ringing_duration, unit: :seconds, comment: "How long bells are ringing"
  end
end
```

--------------------------------

### Configure Default Tags

Source: https://github.com/yabeda-rb/yabeda/blob/master/README.md

Set global or group-specific default tags and override them temporarily using with_tags.

```ruby
Yabeda.configure do
  # matches all metrics in all groups
  default_tag :rails_environment, 'production'

  # matches all metrics in the :your_app group
  default_tag :tag_name, 'override', group: :your_app
end

# You can redefine them for limited amount of time
Yabeda.with_tags(rails_environment: 'staging') do
  Yabeda.your_app.bells_rang_count.increment({bell_size: bell.size}, by: 1)
end
```

--------------------------------

### Limit metrics and groups to specific adapters

Source: https://github.com/yabeda-rb/yabeda/blob/master/README.md

Configure metrics or groups to be handled by specific adapters using the adapter DSL.

```ruby
Yabeda.configure do
  group :internal do
    adapter :prometheus

    counter :foo
    gauge :bar
  end

  group :cloud do
    adapter :newrelic

    counter :baz
  end

  counter :qux, adapter: :prometheus
end
```

```ruby
Yabeda.configure do
  group :mushrooms do
    counter :champignon_counter
  end

  adapter :basket_adapter do
    include_group :mushrooms
  end
end
```

--------------------------------

### Denylist metrics with except

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Creates a denylist for metrics within a group. Listed metrics are silenced, while others remain exposed.

```ruby
Yabeda.except(*metric_names, group: nil)
```

```ruby
Yabeda.configure do
  group :rails do
    except :view_runtime, :db_time
    
    counter :requests_total
    histogram :response_time
    gauge :active_connections
  end
end
```

--------------------------------

### Prevent configuration conflict with check

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/errors.md

Use Yabeda.already_configured? to guard against redundant configuration calls.

```ruby
Yabeda.configure do
  # metric definitions
end

Yabeda.configure! unless Yabeda.already_configured?
```

--------------------------------

### Manage Group Adapters

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-group.md

Register or query adapters associated with a specific group.

```ruby
group.adapter(*adapter_names)
```

```ruby
Yabeda.configure do
  group :internal do
    adapter :prometheus
    counter :internal_calls
  end
  
  group :external do
    adapter :datadog, :newrelic
    counter :external_calls
  end
end

# Query registered adapters
internal_adapters = Yabeda.groups[:internal].adapter
# => [:prometheus]
```

--------------------------------

### Yabeda.adapters

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Returns a hash of all registered adapters keyed by adapter name.

```APIDOC
## Yabeda.adapters

### Description
Returns a hash of all registered adapters keyed by adapter name.

### Signature
`Yabeda.adapters`

### Returns
- **Hash<Symbol, Yabeda::BaseAdapter>** - A hash containing all registered adapters.
```

--------------------------------

### Define and use Summary metrics

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/quick-reference.md

Summaries track distributions without predefined buckets. Supports both block-based and explicit value observation.

```ruby
# Define
summary :query_duration, unit: :seconds, tags: [:query_type]

# Use - with block
Yabeda.database.query_duration.observe({query_type: 'select'}) do
  User.find(1)
end

# Use - with explicit value
Yabeda.database.query_duration.observe({query_type: 'select'}, 0.045)
```

--------------------------------

### Yabeda.configurators

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Returns an array of all queued configuration blocks.

```APIDOC
## Yabeda.configurators

### Description
Returns an array of all queued configuration blocks (pairs of [group, block]).

### Signature
`Yabeda.configurators`

### Returns
- **Array<[Symbol, Proc]>** - An array of configuration blocks.
```

--------------------------------

### Configure Metric-Level Adapter Filtering

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/architecture-overview.md

Specifies adapters for individual metrics, supporting single or multiple backends.

```ruby
Yabeda.configure do
  counter :all_events                           # All adapters
  counter :internal_events, adapter: :prometheus # Prometheus only
  counter :tracking, adapter: [:datadog, :newrelic]  # Multiple adapters
end
```

--------------------------------

### Debug Configuration Errors

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/errors.md

Wrap configuration in a begin-rescue block to catch Yabeda::ConfigurationError and inspect error messages or backtraces.

```ruby
require 'yabeda'

Yabeda.configure do
  group :api do
    counter :requests
    # Typo in adapter name
    gauge :memory, adapter: :promtheus  # Should be :prometheus
  end
end

begin
  Yabeda.configure!
rescue Yabeda::ConfigurationError => e
  puts "Error: #{e.message}"
  puts e.backtrace
end
```

--------------------------------

### metric.adapters

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-metric-classes.md

Returns the adapters this metric is registered with.

```APIDOC
## metric.adapters

### Description
Returns the adapters this metric is registered with. If a specific adapter was set, returns only that adapter. Otherwise returns all registered adapters.

### Returns
Hash<Symbol, Yabeda::BaseAdapter>
```

--------------------------------

### Register a summary metric

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-adapters.md

Called when a summary metric is registered. Must be implemented by adapters that support summaries.

```ruby
adapter.register_summary!(metric)
```

--------------------------------

### Recording histogram measurements

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-metric-classes.md

Demonstrates configuring a histogram and recording values via blocks or direct numeric input.

```ruby
Yabeda.configure do
  group :api do
    histogram :request_duration, unit: :seconds, tags: [:endpoint]
  end
end

# Measure a block
Yabeda.api.request_duration.measure({endpoint: '/users'}) do
  User.all.count
end

# Record a pre-calculated value
Yabeda.api.request_duration.measure({endpoint: '/users'}, 0.245)

# Histogram values are stored but typically reported by adapter
# (e.g., Prometheus creates buckets, summaries, and quantiles)
```

--------------------------------

### Yabeda.only

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Creates an allowlist of metrics in a group. Only listed metrics are exposed; others are silenced.

```APIDOC
## Yabeda.only(*metric_names, group: nil)

### Description
Creates an allowlist of metrics in a group. Only listed metrics are exposed; others are silenced (use null adapter).

### Parameters
- **metric_names** (Array<Symbol>) - Required - Metric names to allow
- **group** (Symbol) - Optional - Group to apply filter to

### Returns
nil
```

--------------------------------

### Initializing RSpec Matchers

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/types.md

Instantiates specific RSpec matchers for verifying metric behavior. These matchers support chainable methods for testing.

```ruby
# RSpec matcher base class
matcher = Yabeda::RSpec::BaseMatcher.new(metric)

# Specific matcher types
counter_matcher = Yabeda::RSpec::IncrementYabedaCounter.new(metric)
gauge_matcher = Yabeda::RSpec::UpdateYabedaGauge.new(metric)
histogram_matcher = Yabeda::RSpec::MeasureYabedaHistogram.new(metric)
summary_matcher = Yabeda::RSpec::ObserveYabedaSummary.new(metric)
```

--------------------------------

### Configure Yabeda metrics

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Registers configuration blocks for metric definitions. Blocks can be queued before calling configure! or executed immediately after.

```ruby
Yabeda.configure(&block)
```

```ruby
# Basic configuration
Yabeda.configure do
  group :myapp do
    counter :requests_total, comment: "Total requests"
    gauge :memory_usage, comment: "Current memory in MB"
  end
end

# After Yabeda.configure!, blocks execute immediately
Yabeda.configure! 
Yabeda.configure do
  group :runtime do
    histogram :processing_time, unit: :seconds
  end
end
```

--------------------------------

### Configure Default Tags

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/configuration.md

Set global or group-specific default tags that are automatically applied to metrics.

```ruby
Yabeda.configure do
  # Global default tags (applied to all metrics)
  default_tag :environment, 'production'
  default_tag :service, 'api'
  
  group :payments do
    # Group-specific default tags
    default_tag :payment_provider, 'stripe'
    
    counter :transactions, tags: [:currency]
  end
end

# Tag precedence (highest to lowest):
# 1. Explicitly provided tags in increment/set/measure
# 2. Thread-local tags (via Yabeda.with_tags)
# 3. Group default tags
# 4. Global default tags

# Usage example
Yabeda.payments.transactions.increment({currency: 'USD'})
# Reported with tags: environment=production, service=api, payment_provider=stripe, currency=USD
```

--------------------------------

### Collect Periodic Metrics

Source: https://github.com/yabeda-rb/yabeda/blob/master/README.md

Use the collect block to report application state periodically.

```ruby
Yabeda.configure do
  # This block will be executed periodically few times in a minute
  # (by timer or external request depending on adapter you're using)
  # Keep it fast and simple!
  collect do
    your_app.whistles_active.set({}, Whistle.where(state: :active).count)
  end
end
```

--------------------------------

### Yabeda.config

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Returns the Yabeda configuration object.

```APIDOC
## Yabeda.config

### Description
Returns the Yabeda configuration object (handles YABEDA_* environment variables).

### Signature
`Yabeda.config`

### Returns
- **Yabeda::Config** - The configuration object.
```

--------------------------------

### Instantiate Yabeda Group

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-group.md

Directly create a new group instance.

```ruby
Yabeda::Group.new(name)
```

--------------------------------

### Query queued configurators

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Returns an array of all queued configuration blocks as pairs of [group, block].

```ruby
Yabeda.configurators
```

--------------------------------

### Yabeda.except

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Creates a denylist of metrics in a group. Listed metrics are silenced; others are exposed.

```APIDOC
## Yabeda.except(*metric_names, group: nil)

### Description
Creates a denylist of metrics in a group. Listed metrics are silenced; others are exposed.

### Parameters
- **metric_names** (Array<Symbol>) - Required - Metric names to exclude
- **group** (Symbol) - Optional - Group to apply filter to

### Returns
nil
```

--------------------------------

### Query global default tags

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Returns a hash of all global default tags.

```ruby
Yabeda.default_tags
```

--------------------------------

### Yabeda.configured?

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Checks whether Yabeda.configure! has been called.

```APIDOC
## Yabeda.configured?

### Description
Checks whether `Yabeda.configure!` has been called. Also available as `Yabeda.already_configured?`.

### Signature
`Yabeda.configured?`

### Returns
- **Boolean** - True if configured, false otherwise.
```

--------------------------------

### Enable Debug Mode via Environment Variable

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/configuration.md

Set the YABEDA_DEBUG environment variable to true to enable internal Yabeda metrics.

```bash
YABEDA_DEBUG=true bundle exec rails server
```

--------------------------------

### Retrieve Metric Adapters

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-metric-classes.md

Returns the adapters registered for a specific metric.

```ruby
metric.adapters
```

--------------------------------

### Define Allowed Tags

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/configuration.md

Specify tags during metric creation and provide them when incrementing the metric.

```ruby
Yabeda.configure do
  group :http do
    counter :requests, tags: [:method, :status, :endpoint]
  end
end

# Later, when incrementing:
Yabeda.http.requests.increment({method: 'GET', status: 200, endpoint: '/api/users'})
```

--------------------------------

### Summary Metric

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/quick-reference.md

Summaries measure distributions without predefined buckets.

```APIDOC
## Summary Metric

### Description
Measures distributions without predefined buckets.

### Usage
```ruby
# Define
summary :query_duration, unit: :seconds, tags: [:query_type]

# Use - with block
Yabeda.database.query_duration.observe({query_type: 'select'}) do
  User.find(1)
end

# Use - with explicit value
Yabeda.database.query_duration.observe({query_type: 'select'}, 0.045)
```
```

--------------------------------

### Yabeda.debug!

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Enables debug mode, which registers internal Yabeda metrics to monitor performance.

```APIDOC
## Yabeda.debug!

### Description
Enables debug mode, which registers internal Yabeda metrics to monitor performance. Creates a `yabeda.collect_duration` histogram tracking collector execution time.

### Returns
true if debug mode was enabled, false if already enabled
```

--------------------------------

### Define and use Tags

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/types.md

Tags are represented as a Hash mapping symbols to strings, used for labeling metric data points.

```ruby
# Type alias: Hash of tag names to values
Tags = Hash<Symbol => String>

# Example usage
tags = { method: 'GET', status: '200', endpoint: '/api/users' }
```

--------------------------------

### Explicitly configure Yabeda in Rails

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/configuration.md

Manually trigger configuration finalization if automatic initialization is insufficient.

```ruby
# In an initializer
Yabeda.configure do
  # ... metric definitions
end

# Explicitly finalize if needed
Yabeda.configure! unless Yabeda.already_configured?
```

--------------------------------

### Enable debug mode programmatically

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/configuration.md

Use the debug! method as a programmatic alternative to setting the YABEDA_DEBUG environment variable.

```ruby
Yabeda.debug!
```

--------------------------------

### Register Metric Instance

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-group.md

Manually register a metric instance to make it accessible via the group.

```ruby
group.register_metric(metric)
```

```ruby
# This is called internally by the DSL
counter = Yabeda::Counter.new(:requests, group: :api)
Yabeda.groups[:api].register_metric(counter)

# After registration, accessible via:
Yabeda.api.requests  # => counter instance
```

--------------------------------

### Monitor Database Connections

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/quick-reference.md

Configure a collector to report the current ActiveRecord connection pool size.

```ruby
Yabeda.configure do
  collect do
    system.db_connections.set({}, ActiveRecord::Base.connection_pool.size)
  end
end
```

--------------------------------

### Summary#observe

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-metric-classes.md

Records an observation in a summary metric. Supports either a block to measure execution time or a direct numeric value.

```APIDOC
## Summary#observe

### Description
Records an observation in the summary. Either a value or a block must be provided.

### Parameters
- **tags** (Hash<Symbol => String>) - Optional - Label values
- **value** (Numeric) - Optional - Pre-calculated value to record
- **block** (Proc) - Optional - Block to measure; timing is calculated

### Returns
- **Numeric** - The recorded value (seconds if block given)

### Raises
- **ArgumentError** - If neither value nor block provided, or both provided
```

--------------------------------

### Implement Request ID Tracking

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/tags-system.md

Configures a default request ID tag and uses middleware to inject the ID into metric tags for every request.

```ruby
Yabeda.configure do
  # All metrics can have request_id
  default_tag :request_id, ''
  
  group :myapp do
    counter :requests
    histogram :response_time
  end
end

# In Rails middleware
class YabedaMiddleware
  def initialize(app)
    @app = app
  end
  
  def call(env)
    request_id = env['HTTP_X_REQUEST_ID'] || SecureRandom.uuid
    Yabeda.with_tags(request_id: request_id) do
      @app.call(env)
    end
  end
end
```

--------------------------------

### Configure Global Default Tags

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/tags-system.md

Registers tags that apply to all metrics across all groups within the Yabeda configuration block.

```ruby
Yabeda.configure do
  default_tag :environment, ENV['RAILS_ENV'] || 'development'
  default_tag :service_name, 'my-api'
  default_tag :version, '1.2.3'
  
  group :myapp do
    counter :requests
  end
end

# All metrics get these tags automatically
Yabeda.myapp.requests.increment({})
# Reported with: environment=development, service_name=my-api, version=1.2.3
```

--------------------------------

### Handle tag definition constraints

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/tags-system.md

Tags used in with_tags must be defined on all metrics within the block. Ensure all metrics include the required tags in their configuration.

```ruby
# Wrong: 'trace_id' is not defined on all metrics
Yabeda.configure do
  group :api do
    counter :requests, tags: [:method]  # No trace_id!
    gauge :active, tags: [:trace_id]    # Has trace_id
  end
end

Yabeda.with_tags(trace_id: 'abc') do
  Yabeda.api.requests.increment({method: 'GET'})  # Error!
end
```

```ruby
Yabeda.configure do
  group :api do
    counter :requests, tags: [:method, :trace_id]
    gauge :active, tags: [:trace_id]
  end
end

Yabeda.with_tags(trace_id: 'abc') do
  Yabeda.api.requests.increment({method: 'GET'})  # Works
  Yabeda.api.active.set({}, 5)                    # Works
end
```

--------------------------------

### with Method Definition

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-rspec.md

Specifies expectations for multiple tag sets or value validation.

```ruby
def with(expectations)
```

--------------------------------

### Configure default tags

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/quick-reference.md

Global default tags are applied to all metrics, while group-level tags apply only to metrics within a specific group.

```ruby
Yabeda.configure do
  default_tag :environment, 'production'
  default_tag :service, 'api'
  
  counter :requests_total
end

# Metrics automatically include default tags
Yabeda.requests_total.increment({})
# Reported with: environment=production, service=api
```

```ruby
Yabeda.configure do
  group :payments do
    default_tag :provider, 'stripe'
    counter :transactions, tags: [:currency]
  end
end

Yabeda.payments.transactions.increment({currency: 'USD'})
# Reported with: provider=stripe, currency=USD
```

--------------------------------

### Configure Periodic Collectors

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/quick-reference.md

Define blocks to report application state periodically. Keep these operations fast and avoid heavy I/O.

```ruby
Yabeda.configure do
  collect do
    system.database_connections.set({}, ActiveRecord::Base.connection_pool.size)
    system.background_jobs.set({}, Job.where(status: :pending).count)
  end
end
```

--------------------------------

### Record a summary observation

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-adapters.md

Called when a summary observation is recorded. Must be implemented by adapters that support summaries.

```ruby
adapter.perform_summary_observe!(summary, tags, value)
```

```ruby
class MyAdapter < Yabeda::BaseAdapter
  def perform_summary_observe!(summary, tags, value)
    @backend.record_summary(summary.name, tags, value)
  end
end
```

--------------------------------

### Access Queued Configurators

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/types.md

Access the array of configuration blocks waiting for execution via Yabeda.configure!.

```ruby
# Type: Array<[Symbol / nil, Proc]>
configurators = Yabeda.configurators
# Each element is a pair of [group, configuration_block]

configurators.each do |group, block|
  puts "Config block for group: #{group || 'global'}"
end
```

--------------------------------

### Inspect Metric Definitions

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/errors.md

Access registered metrics via Yabeda.metrics or specific group namespaces to verify configuration details like tags and adapters.

```ruby
Yabeda.configure do
  group :api do
    counter :requests, tags: [:method, :status]
  end
end

Yabeda.configure!

# Inspect all metrics
Yabeda.metrics.each do |name, metric|
  puts "#{name}: #{metric.class}"
end

# Inspect a specific metric
metric = Yabeda.api.requests
puts "Name: #{metric.name}"
puts "Group: #{metric.group}"
puts "Tags: #{metric.tags}"
puts "Adapters: #{metric.adapters.keys}"
```

--------------------------------

### Configure and Access Yabeda Metrics

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-metric-classes.md

Define metrics within a group and access them using either group property methods or string keys.

```ruby
Yabeda.configure do
  group :myapp do
    counter :requests
    gauge :active_users
    histogram :response_time
    summary :db_query_duration
  end
end

# Access via group (after configure!)
Yabeda.myapp.requests          # => Yabeda::Counter instance
Yabeda.myapp.active_users      # => Yabeda::Gauge instance
Yabeda.myapp.response_time     # => Yabeda::Histogram instance
Yabeda.myapp.db_query_duration # => Yabeda::Summary instance

# Access via string key
Yabeda.metrics['myapp_requests']
```

--------------------------------

### by Method Definition

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-rspec.md

Defines the expected increment amount for a counter.

```ruby
def by(increment)
```

--------------------------------

### Push release tags

Source: https://github.com/yabeda-rb/yabeda/blob/master/README.md

Push commits and tags to the remote repository.

```sh
git push --follow-tags
```

--------------------------------

### Track Background Job Metrics

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/quick-reference.md

Define counters and histograms for Sidekiq jobs and record metrics during job execution.

```ruby
Yabeda.configure do
  group :sidekiq do
    counter :jobs_processed
    histogram :job_duration, unit: :seconds
  end
  
  collect do
    sidekiq.queued_jobs.set({}, Sidekiq::Stats.new.processes_size)
  end
end

# In job
Yabeda.sidekiq.jobs_processed.increment({})
Yabeda.sidekiq.job_duration.measure({}) { perform_work }
```

--------------------------------

### Default Tag Method Signature

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/tags-system.md

The method signature for registering default tags.

```ruby
Yabeda.default_tag(name, value, group: nil)
```

--------------------------------

### Yabeda::Group.new(name)

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-group.md

Instantiates a new metric group with the specified name.

```APIDOC
## Yabeda::Group.new(name)

### Description
Creates a new instance of a metric group. Groups are typically created via the Yabeda DSL but can be instantiated directly.

### Parameters
- **name** (Symbol/String) - Required - Group identifier
```

--------------------------------

### Define and use Histogram metrics

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/quick-reference.md

Histograms measure value distributions. Timing can be automated using a block or set explicitly.

```ruby
# Define
histogram :request_duration, unit: :seconds, tags: [:endpoint]

# Use - with block (timing is automatic)
Yabeda.api.request_duration.measure({endpoint: '/users'}) do
  User.all.load
end

# Use - with explicit value
elapsed = Time.now
User.all.load
elapsed = Time.now - elapsed
Yabeda.api.request_duration.measure({endpoint: '/users'}, elapsed)
```

--------------------------------

### Yabeda.adapter

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Limits metric or group registration to specific adapters. Metrics outside specified adapters use the null adapter.

```APIDOC
## Yabeda.adapter(*adapter_names, group: nil, &block)

### Description
Limits metric or group registration to specific adapters. Metrics outside specified adapters use the null adapter.

### Parameters
- **adapter_names** (Array<Symbol>) - Required - Adapter names to use
- **group** (Symbol) - Optional - Group to apply limitation to
- **block** (Proc) - Optional - Block with include_group calls

### Returns
nil or block return value
```

--------------------------------

### debug!

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-adapters.md

Hook called when debug mode is enabled. Adapters can implement this to set up performance monitoring.

```APIDOC
## debug!

### Description
Hook called when debug mode is enabled via Yabeda.debug!. Adapters can implement this to set up performance monitoring.

### Returns
- nil
```

--------------------------------

### Finalize Yabeda configuration

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/api-reference-yabeda-module.md

Finalizes the configuration process by evaluating queued blocks. Must be called once before metrics are used.

```ruby
Yabeda.configure!
```

```ruby
Yabeda.configure do
  group :myapp do
    counter :events_total
  end
end

Yabeda.configure!  # Finalizes configuration
```

--------------------------------

### Scope Adapter to Group

Source: https://github.com/yabeda-rb/yabeda/blob/master/_autodocs/errors.md

Shows the error of calling adapter outside a group context and the correct ways to scope it.

```ruby
# Wrong - no group context
Yabeda.adapter(:prometheus)
counter :events
```

```ruby
# Correct - inside group
Yabeda.configure do
  group :api do
    adapter :prometheus
    counter :events
  end
end

# Or with block
Yabeda.configure do
  adapter :prometheus do
    include_group :api
  end
end
```
Tokens:
Raw