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

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using NewRelic.Api.Agent;

public class Startup
{
    private readonly IConfiguration _configuration;
    
    public Startup(IConfiguration configuration)
    {
        _configuration = configuration;
    }
    
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllers();
        
        // New Relic サービスの追加（設定を外部化）
        services.AddNewRelicTelemetry(_configuration);
    }
    
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        
        app.UseRouting();
        app.UseAuthorization();
        
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }
}

using Microsoft.AspNetCore.Mvc;
using NewRelic.Api.Agent;

[ApiController]
[Route("api/[controller]")]
public class OrdersController : ControllerBase
{
    private readonly IOrderService _orderService;
    
    public OrdersController(IOrderService orderService)
    {
        _orderService = orderService;
    }
    
    [HttpPost]
    [Trace(MetricName = "Custom/Orders/Create")]
    public async Task<IActionResult> CreateOrder([FromBody] CreateOrderRequest request)
    {
        try
        {
            var order = await _orderService.CreateOrderAsync(request);
            
            // カスタムメトリクスの記録
            NewRelic.RecordMetric("Custom/Orders/Created", 1);
            NewRelic.AddCustomAttribute("order.value", order.TotalAmount);
            
            return Ok(order);
        }
        catch (Exception ex)
        {
            NewRelic.NoticeError(ex);
            return StatusCode(500, "Internal server error");
        }
    }
    
    [HttpGet("{id}")]
    public async Task<IActionResult> GetOrder(int id)
    {
        return NewRelic.GetAgent().NewRelic.SetTransactionName("Custom", "GetOrder")
            ? Ok(await _orderService.GetOrderAsync(id))
            : NotFound();
    }
}

using Microsoft.EntityFrameworkCore;
using NewRelic.Api.Agent;

public class ApplicationDbContext : DbContext
{
    public DbSet<Order> Orders { get; set; }
    public DbSet<Customer> Customers { get; set; }
    
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer(connectionString);
        
        // New Relic による SQL 監視の有効化
        optionsBuilder.EnableSensitiveDataLogging(false);
        optionsBuilder.LogTo(Console.WriteLine);
    }
}

public class OrderService : IOrderService
{
    private readonly ApplicationDbContext _context;
    
    public OrderService(ApplicationDbContext context)
    {
        _context = context;
    }
    
    [Trace(MetricName = "Database/Orders/GetByCustomer")]
    public async Task<List<Order>> GetOrdersByCustomerAsync(int customerId)
    {
        return await _context.Orders
            .Where(o => o.CustomerId == customerId)
            .Include(o => o.Items)
            .ToListAsync();
    }
}

using NewRelic.Api.Agent;

public class PaymentService
{
    [Trace(MetricName = "Custom/Payment/Process")]
    public async Task<PaymentResult> ProcessPaymentAsync(PaymentRequest request)
    {
        var startTime = DateTime.UtcNow;
        
        try
        {
            var result = await CallPaymentGatewayAsync(request);
            
            // 成功メトリクスの記録
            NewRelic.RecordMetric("Custom/Payment/Success", 1);
            NewRelic.RecordMetric("Custom/Payment/Amount", request.Amount);
            
            // カスタムイベントの記録
            NewRelic.RecordCustomEvent("PaymentProcessed", new Dictionary<string, object>
            {
                ["amount"] = request.Amount,
                ["currency"] = request.Currency,
                ["gateway"] = result.Gateway,
                ["processingTime"] = (DateTime.UtcNow - startTime).TotalMilliseconds
            });
            
            return result;
        }
        catch (Exception ex)
        {
            NewRelic.NoticeError(ex);
            NewRelic.RecordMetric("Custom/Payment/Error", 1);
            throw;
        }
    }
    
    [Trace(MetricName = "External/PaymentGateway/Call")]
    private async Task<PaymentResult> CallPaymentGatewayAsync(PaymentRequest request)
    {
        // 外部サービス呼び出し
        using var httpClient = new HttpClient();
        var response = await httpClient.PostAsJsonAsync("/api/payments", request);
        return await response.Content.ReadFromJsonAsync<PaymentResult>();
    }
}

using NewRelic.Api.Agent;
using Microsoft.Extensions.Hosting;

public class EmailProcessingService : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            await ProcessEmailQueueAsync();
            await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
        }
    }
    
    [Trace(MetricName = "BackgroundTask/EmailProcessing")]
    private async Task ProcessEmailQueueAsync()
    {
        var emails = await GetPendingEmailsAsync();
        
        foreach (var email in emails)
        {
            await ProcessSingleEmailAsync(email);
        }
        
        NewRelic.RecordMetric("Custom/EmailsProcessed", emails.Count);
    }
    
    [Trace(MetricName = "Email/Send")]
    private async Task ProcessSingleEmailAsync(EmailMessage email)
    {
        try
        {
            await SendEmailAsync(email);
            NewRelic.AddCustomAttribute("email.type", email.Type);
            NewRelic.AddCustomAttribute("email.recipient", email.To);
        }
        catch (Exception ex)
        {
            NewRelic.NoticeError(ex);
            throw;
        }
    }
}

using System.Diagnostics;
using NewRelic.Api.Agent;

public class PerformanceMonitoringService : IHostedService
{
    private readonly Timer _timer;
    
    public PerformanceMonitoringService()
    {
        _timer = new Timer(RecordPerformanceMetrics, null, TimeSpan.Zero, TimeSpan.FromMinutes(1));
    }
    
    private void RecordPerformanceMetrics(object state)
    {
        var process = Process.GetCurrentProcess();
        
        // メモリ使用量
        NewRelic.RecordMetric("Custom/Memory/WorkingSet", process.WorkingSet64);
        NewRelic.RecordMetric("Custom/Memory/PrivateMemory", process.PrivateMemorySize64);
        
        // CPU 使用率
        NewRelic.RecordMetric("Custom/CPU/ProcessorTime", process.TotalProcessorTime.TotalMilliseconds);
        
        // ガベージコレクション
        for (int i = 0; i <= GC.MaxGeneration; i++)
        {
            NewRelic.RecordMetric($"Custom/GC/Gen{i}Collections", GC.CollectionCount(i));
        }
    }
    
    public Task StartAsync(CancellationToken cancellationToken) => Task.CompletedTask;
    public Task StopAsync(CancellationToken cancellationToken)
    {
        _timer?.Dispose();
        return Task.CompletedTask;
    }
}

using NewRelic.Api.Agent;

public class DiagnosticsController : ControllerBase
{
    [HttpGet("health/newrelic")]
    public IActionResult NewRelicHealth()
    {
        var agent = NewRelic.GetAgent();
        var traceMetadata = NewRelic.GetTraceMetadata();
        
        return Ok(new
        {
            AgentEnabled = agent != null,
            TraceId = traceMetadata.TraceId,
            SpanId = traceMetadata.SpanId,
            Configuration = new
            {
                AppName = Environment.GetEnvironmentVariable("NEW_RELIC_APP_NAME"),
                LicenseKeyConfigured = !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("NEW_RELIC_LICENSE_KEY"))
            }
        });
    }
}