Ruby アプリケーション向け New Relic APM 設定ガイド ​

# Gemfile
gem 'newrelic_rpm'

# Gemfile
gem 'dotenv-rails', groups: [:development, :test]

# config/application.rb
if Rails.env.development? || Rails.env.test?
  require 'dotenv/rails-now'
end

# config/application.rb
module MyApp
  class Application < Rails::Application
    # New Relic の初期化設定（任意）
    config.after_initialize do
      if defined?(NewRelic::Agent)
        NewRelic::Agent.manual_start
      end
    end
  end
end

# app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
  before_action :set_newrelic_user_attributes
  
  private
  
  def set_newrelic_user_attributes
    if current_user && defined?(NewRelic::Agent)
      NewRelic::Agent.set_user_attributes(
        user_id: current_user.id,
        user_name: current_user.name,
        user_email: current_user.email
      )
    end
  end
end

# app.rb
require 'sinatra'
require 'newrelic_rpm'

class MyApp < Sinatra::Base
  configure do
    NewRelic::Agent.manual_start(
      app_name: 'My Sinatra App',
      license_key: ENV['NEW_RELIC_LICENSE_KEY']
    )
  end
  
  get '/api/users/:id' do
    content_type :json
    user = User.find(params[:id])
    user.to_json
  end
end

# カスタムメトリクスの記録
if defined?(NewRelic::Agent)
  NewRelic::Agent.record_custom_metric('Custom/Revenue', order.total_amount)
  NewRelic::Agent.record_custom_metric('Custom/OrdersProcessed', 1)
  
  # カスタムイベントの記録
  NewRelic::Agent.record_custom_event('OrderCreated', {
    order_id: order.id,
    customer_id: order.customer_id,
    total_amount: order.total_amount
  })
end

class OrdersController < ApplicationController
  def create
    @order = NewRelic::Agent::MethodTracer.trace_execution_scoped("Custom/Orders/Create") do
      Order.create(order_params)
    end
    
    if @order.persisted?
      # 成功メトリクスの記録
      NewRelic::Agent.record_custom_metric("Custom/Orders/Created", 1)
      redirect_to @order, notice: 'Order was successfully created.'
    else
      render :new
    end
  end
end

# config/deploy.rb
after 'deploy:updated', 'newrelic:notice_deployment'

namespace :newrelic do
  desc 'Notify New Relic of deployment'
  task :notice_deployment do
    on roles(:app) do
      within release_path do
        execute :bundle, :exec, 'newrelic', 'deployments', 
                '--revision', fetch(:current_revision),
                '--description', "Deployed at #{Time.current}"
      end
    end
  end
end

# app/controllers/health_controller.rb
class HealthController < ApplicationController
  def newrelic_status
    diagnostics = NewRelicDiagnostics.new
    render json: diagnostics.run_full_check
  end
end

# lib/new_relic_diagnostics.rb
class NewRelicDiagnostics
  def run_full_check
    {
      gem_loaded: gem_loaded_check,
      agent_status: agent_status_check,
      configuration: configuration_check,
      connectivity: connectivity_check,
      framework_integration: framework_integration_check,
      environment: environment_check
    }
  end

  private

  def gem_loaded_check
    {
      newrelic_rpm_loaded: defined?(NewRelic::Agent),
      version: defined?(NewRelic::VERSION) ? NewRelic::VERSION::STRING : 'N/A'
    }
  end

  def agent_status_check
    return { status: 'not_loaded' } unless defined?(NewRelic::Agent)
    
    {
      started: NewRelic::Agent.agent.started?,
      connected: NewRelic::Agent.agent.connected?,
      monitor_mode: NewRelic::Agent.config[:monitor_mode]
    }
  end

  def configuration_check
    return { status: 'agent_not_loaded' } unless defined?(NewRelic::Agent)
    
    config = NewRelic::Agent.config
    {
      app_name: config[:app_name],
      license_key_present: config[:license_key].present?,
      license_key_format: config[:license_key]&.length == 40,
      environment: config[:environment],
      log_level: config[:log_level],
      high_security: config[:high_security]
    }
  end

  def connectivity_check
    return { status: 'agent_not_loaded' } unless defined?(NewRelic::Agent)
    
    begin
      # 接続テスト（簡易版）
      {
        host: NewRelic::Agent.config[:host],
        port: NewRelic::Agent.config[:port],
        ssl: NewRelic::Agent.config[:ssl],
        proxy_host: NewRelic::Agent.config[:proxy_host]
      }
    rescue => e
      { error: e.message }
    end
  end

  def framework_integration_check
    {
      rails_version: defined?(Rails) ? Rails.version : 'N/A',
      sinatra_detected: defined?(Sinatra),
      rack_version: defined?(Rack) ? Rack.version : 'N/A',
      middleware_loaded: rails_middleware_check
    }
  end

  def environment_check
    {
      ruby_version: RUBY_VERSION,
      rails_env: defined?(Rails) ? Rails.env : ENV['RACK_ENV'] || 'unknown',
      bundler_version: defined?(Bundler) ? Bundler::VERSION : 'N/A',
      pid: Process.pid
    }
  end

  def rails_middleware_check
    return false unless defined?(Rails) && Rails.application

    Rails.application.middleware.middlewares.any? do |middleware|
      middleware.to_s.include?('NewRelic')
    end
  end
end

# config/application.rb で明示的にNew Relicを有効化
module MyApp
  class Application < Rails::Application
    # New Relic の明示的初期化
    config.after_initialize do
      if defined?(NewRelic::Agent) && !NewRelic::Agent.agent.started?
        NewRelic::Agent.manual_start
      end
    end
  end
end

# コントローラーで明示的なインスツルメンテーション
class ApplicationController < ActionController::Base
  # New Relic インスツルメンテーションの強制有効化
  newrelic_ignore_apdex if respond_to?(:newrelic_ignore_apdex)
  
  around_action :ensure_newrelic_transaction
  
  private
  
  def ensure_newrelic_transaction
    if defined?(NewRelic::Agent)
      # トランザクションが開始されていない場合は手動で開始
      unless NewRelic::Agent.current_transaction
        NewRelic::Agent.start_transaction(
          name: "Controller/#{controller_name}##{action_name}",
          category: :controller
        )
      end
    end
    
    yield
    
  ensure
    # カスタム属性の追加
    if defined?(NewRelic::Agent)
      NewRelic::Agent.add_custom_attributes(
        controller: controller_name,
        action: action_name,
        request_method: request.request_method,
        response_status: response.status
      )
    end
  end
end

# config/initializers/sidekiq.rb
Sidekiq.configure_server do |config|
  # New Relic Sidekiq統合の強制有効化
  if defined?(NewRelic::Agent)
    require 'newrelic_rpm'
    require 'newrelic/agent/instrumentation/sidekiq'
  end
end

# ワーカークラスでの明示的な統合
class MyWorker
  include Sidekiq::Worker
  
  # New Relic統合の明示的な追加
  if defined?(NewRelic::Agent::Instrumentation::Sidekiq)
    include NewRelic::Agent::Instrumentation::Sidekiq
  end
  
  def perform(*args)
    # New Relicトランザクションの手動開始（フォールバック）
    transaction_name = "SidekiqJob/#{self.class.name}"
    
    if defined?(NewRelic::Agent)
      NewRelic::Agent.set_transaction_name('Background', transaction_name)
      
      NewRelic::Agent.add_custom_attributes(
        job_class: self.class.name,
        job_args_count: args.length,
        sidekiq_queue: self.class.get_sidekiq_options['queue']
      )
    end
    
    # 実際のジョブ処理
    process_job(*args)
    
  rescue => e
    NewRelic::Agent.notice_error(e) if defined?(NewRelic::Agent)
    raise
  end
  
  private
  
  def process_job(*args)
    # ジョブの実装
  end
end

# config/initializers/memory_monitoring.rb
if Rails.env.production?
  # メモリ監視スレッドの開始
  Thread.new do
    loop do
      begin
        # プロセスメモリ情報の取得
        if RUBY_PLATFORM =~ /linux/
          status_file = "/proc/#{Process.pid}/status"
          if File.exist?(status_file)
            status = File.read(status_file)
            
            # VmRSS（物理メモリ）の取得
            if match = status.match(/VmRSS:\s+(\d+)\s+kB/)
              rss_kb = match[1].to_i
              rss_mb = rss_kb / 1024.0
              
              NewRelic::Agent.record_custom_metric('Custom/Memory/RSS_MB', rss_mb)
              
              # メモリアラート（1GB超過時）
              if rss_mb > 1024
                NewRelic::Agent.record_custom_event('MemoryAlert', {
                  pid: Process.pid,
                  memory_mb: rss_mb,
                  alert_level: 'high',
                  timestamp: Time.now.to_i
                })
              end
            end
          end
        end
        
        # Ruby GC統計の記録
        gc_stat = GC.stat
        NewRelic::Agent.record_custom_metric('Custom/GC/Heap/LiveObjects', gc_stat[:heap_live_slots])
        NewRelic::Agent.record_custom_metric('Custom/GC/Heap/FreeObjects', gc_stat[:heap_free_slots])
        NewRelic::Agent.record_custom_metric('Custom/GC/Collections/Major', gc_stat[:major_gc_count])
        NewRelic::Agent.record_custom_metric('Custom/GC/Collections/Minor', gc_stat[:minor_gc_count])
        
        # ObjectSpace統計（開発環境のみ）
        if Rails.env.development?
          ObjectSpace.each_object.group_by(&:class).each do |klass, objects|
            next if objects.size < 100
            NewRelic::Agent.record_custom_metric(
              "Custom/ObjectSpace/#{klass.name.gsub('::', '/')}", 
              objects.size
            )
          end
        end
        
        sleep 60 # 1分間隔
      rescue => e
        Rails.logger.error "Memory monitoring error: #{e.message}"
        sleep 300 # エラー時は5分待機
      end
    end
  end
end

# lib/performance_diagnostics.rb
class PerformanceDiagnostics
  include NewRelic::Agent::MethodTracer
  
  def self.analyze_slow_queries
    # スロークエリの分析
    if defined?(ActiveRecord)
      subscriber = ActiveSupport::Notifications.subscribe('sql.active_record') do |name, start, finish, id, payload|
        duration = finish - start
        
        if duration > 1.0  # 1秒以上のクエリ
          NewRelic::Agent.record_custom_event('SlowQuery', {
            sql: payload[:sql].truncate(500),
            duration_seconds: duration,
            connection_id: payload[:connection_id],
            binds: payload[:binds]&.map(&:value)&.to_s&.truncate(200)
          })
        end
      end
    end
  end
  
  def self.monitor_action_view_rendering
    # ビュー描画時間の監視
    ActiveSupport::Notifications.subscribe('render_template.action_view') do |name, start, finish, id, payload|
      duration = finish - start
      
      if duration > 0.5  # 0.5秒以上の描画
        NewRelic::Agent.record_custom_event('SlowViewRender', {
          template: payload[:identifier],
          duration_seconds: duration,
          layout: payload[:layout]
        })
      end
    end
  end
  
  def self.detect_n_plus_one_queries
    # N+1クエリの検出（簡易版）
    query_counts = Hash.new(0)
    
    ActiveSupport::Notifications.subscribe('sql.active_record') do |name, start, finish, id, payload|
      # 同一SQLの実行回数をカウント
      sql_pattern = payload[:sql].gsub(/\d+/, '?').gsub(/'[^']*'/, '?')
      query_counts[sql_pattern] += 1
      
      # 同一パターンのクエリが多数実行された場合
      if query_counts[sql_pattern] > 10
        NewRelic::Agent.record_custom_event('NPlusOneQuery', {
          sql_pattern: sql_pattern.truncate(300),
          execution_count: query_counts[sql_pattern]
        })
      end
    end
  end
end

# config/initializers/performance_diagnostics.rb
if Rails.env.production?
  PerformanceDiagnostics.analyze_slow_queries
  PerformanceDiagnostics.monitor_action_view_rendering
end

if Rails.env.development?
  PerformanceDiagnostics.detect_n_plus_one_queries
end

# config/newrelic.yml でのデバッグ設定
development:
  <<: *default_settings
  app_name: My Ruby Application (Development)
  log_level: debug
  developer_mode: true
  
  # 詳細ログの有効化
  audit_log:
    enabled: true
    path: log/newrelic_audit.log
  
  # デバッグ用詳細設定
  debug:
    raw_transaction_trace_data: true
    record_transaction_trace_segments: true
    explain_threshold: 0.0
    record_raw_web_transaction_sql: true