New Relic Flutter統合設定 - Dart・ネイティブ統合監視の完全ガイド ​

import 'package:flutter/material.dart';
import 'package:newrelic_mobile/newrelic_mobile.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  
  // New Relic初期化
  NewrelicMobile.instance.start(
    'YOUR_APPLICATION_TOKEN',
    (config) {
      config
        ..loggingEnabled = true
        ..logLevel = LogLevel.info
        ..crashReportingEnabled = true;
    }
  );
  
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter New Relic Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: MyHomePage(title: 'Flutter Demo Home Page'),
    );
  }
}

import 'package:newrelic_mobile/newrelic_mobile.dart';

class AnalyticsService {
  static final NewrelicMobile _newRelic = NewrelicMobile.instance;
  
  // ユーザー属性の設定
  static Future<void> setUserAttributes(String userId, String userType) async {
    await _newRelic.setUserId(userId);
    await _newRelic.setAttribute('userType', userType);
    await _newRelic.setAttribute('flutterVersion', '3.13.0');
    await _newRelic.setAttribute('dartVersion', '3.1.0');
  }
  
  // カスタムイベントの記録
  static Future<void> recordPurchaseEvent({
    required String itemId,
    required double price,
    required String currency,
  }) async {
    await _newRelic.recordCustomEvent('PurchaseCompleted', {
      'itemId': itemId,
      'price': price,
      'currency': currency,
      'platform': 'flutter',
      'timestamp': DateTime.now().millisecondsSinceEpoch,
    });
  }
  
  // カスタムメトリクスの記録
  static Future<void> recordMetric(String name, double value) async {
    await _newRelic.recordMetric(name, value);
  }
  
  // ウィジェットビルド時間の測定
  static Future<void> recordWidgetBuildTime(String widgetName, Duration buildTime) async {
    await _newRelic.recordMetric(
      'Custom/WidgetBuildTime/$widgetName',
      buildTime.inMilliseconds.toDouble()
    );
  }
}

import 'package:flutter/material.dart';
import 'package:newrelic_mobile/newrelic_mobile.dart';

class NavigationObserver extends RouteObserver<PageRoute<dynamic>> {
  @override
  void didPush(Route<dynamic> route, Route<dynamic>? previousRoute) {
    super.didPush(route, previousRoute);
    _recordRouteChange(route.settings.name, 'push');
  }
  
  @override
  void didPop(Route<dynamic> route, Route<dynamic>? previousRoute) {
    super.didPop(route, previousRoute);
    if (previousRoute != null) {
      _recordRouteChange(previousRoute.settings.name, 'pop');
    }
  }
  
  @override
  void didReplace({Route<dynamic>? newRoute, Route<dynamic>? oldRoute}) {
    super.didReplace(newRoute: newRoute, oldRoute: oldRoute);
    if (newRoute != null) {
      _recordRouteChange(newRoute.settings.name, 'replace');
    }
  }
  
  void _recordRouteChange(String? routeName, String action) {
    if (routeName != null) {
      NewrelicMobile.instance.recordCustomEvent('ScreenView', {
        'screenName': routeName,
        'action': action,
        'timestamp': DateTime.now().millisecondsSinceEpoch,
      });
    }
  }
}

// MaterialAppでの使用
class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      navigatorObservers: [NavigationObserver()],
      // 他の設定
    );
  }
}

import 'dart:async';
import 'package:flutter/material.dart';
import 'package:newrelic_mobile/newrelic_mobile.dart';

void main() {
  // エラーハンドリングの設定
  runZonedGuarded(() async {
    WidgetsFlutterBinding.ensureInitialized();
    
    // New Relic初期化
    await NewrelicMobile.instance.start('YOUR_APPLICATION_TOKEN');
    
    // Flutter frameworkエラーの捕捉
    FlutterError.onError = (FlutterErrorDetails details) {
      NewrelicMobile.instance.recordError(
        details.exception,
        details.stack,
        attributes: {
          'errorType': 'FlutterError',
          'library': details.library ?? 'unknown',
          'context': details.context.toString(),
        }
      );
    };
    
    runApp(MyApp());
  }, (error, stackTrace) {
    // Zone内の未処理エラーの捕捉
    NewrelicMobile.instance.recordError(
      error,
      stackTrace,
      attributes: {
        'errorType': 'ZonedGuardedError',
        'isFatal': true,
      }
    );
  });
}

// カスタムエラー境界
class ErrorBoundary extends StatefulWidget {
  final Widget child;
  
  const ErrorBoundary({Key? key, required this.child}) : super(key: key);
  
  @override
  _ErrorBoundaryState createState() => _ErrorBoundaryState();
}

class _ErrorBoundaryState extends State<ErrorBoundary> {
  bool hasError = false;
  
  @override
  Widget build(BuildContext context) {
    if (hasError) {
      return Scaffold(
        body: Center(
          child: Text('Something went wrong'),
        ),
      );
    }
    
    return widget.child;
  }
  
  @override
  void initState() {
    super.initState();
    
    // エラー監視の設定
    FlutterError.onError = (FlutterErrorDetails details) {
      setState(() {
        hasError = true;
      });
      
      NewrelicMobile.instance.recordError(
        details.exception,
        details.stack,
        attributes: {
          'component': 'ErrorBoundary',
          'widgetTree': details.toString(),
        }
      );
    };
  }
}

import 'package:http/http.dart' as http;
import 'package:newrelic_mobile/newrelic_mobile.dart';

class MonitoredHttpClient {
  static final http.Client _client = http.Client();
  
  static Future<http.Response> get(Uri url, {Map<String, String>? headers}) async {
    return _monitorRequest(() => _client.get(url, headers: headers), 'GET', url);
  }
  
  static Future<http.Response> post(
    Uri url, {
    Map<String, String>? headers,
    Object? body,
  }) async {
    return _monitorRequest(
      () => _client.post(url, headers: headers, body: body),
      'POST',
      url
    );
  }
  
  static Future<http.Response> _monitorRequest(
    Future<http.Response> Function() request,
    String method,
    Uri url,
  ) async {
    final startTime = DateTime.now();
    
    try {
      final response = await request();
      final endTime = DateTime.now();
      final duration = endTime.difference(startTime);
      
      // 成功時のメトリクス記録
      await NewrelicMobile.instance.recordMetric(
        'Custom/HttpRequest/Success',
        duration.inMilliseconds.toDouble()
      );
      
      await NewrelicMobile.instance.recordCustomEvent('HttpRequest', {
        'method': method,
        'url': url.toString(),
        'statusCode': response.statusCode,
        'duration': duration.inMilliseconds,
        'success': true,
      });
      
      return response;
    } catch (error, stackTrace) {
      final endTime = DateTime.now();
      final duration = endTime.difference(startTime);
      
      // エラー時のメトリクス記録
      await NewrelicMobile.instance.recordMetric(
        'Custom/HttpRequest/Error',
        duration.inMilliseconds.toDouble()
      );
      
      await NewrelicMobile.instance.recordError(
        error,
        stackTrace,
        attributes: {
          'method': method,
          'url': url.toString(),
          'requestType': 'http',
        }
      );
      
      rethrow;
    }
  }
}

import 'package:flutter/material.dart';
import 'package:newrelic_mobile/newrelic_mobile.dart';

class PerformanceMonitoredWidget extends StatefulWidget {
  final Widget child;
  final String widgetName;
  
  const PerformanceMonitoredWidget({
    Key? key,
    required this.child,
    required this.widgetName,
  }) : super(key: key);
  
  @override
  _PerformanceMonitoredWidgetState createState() => _PerformanceMonitoredWidgetState();
}

class _PerformanceMonitoredWidgetState extends State<PerformanceMonitoredWidget> {
  @override
  Widget build(BuildContext context) {
    final startTime = DateTime.now();
    
    return NotificationListener(
      onNotification: (notification) {
        if (notification is! Notification) return false;
        
        WidgetsBinding.instance.addPostFrameCallback((_) {
          final endTime = DateTime.now();
          final buildTime = endTime.difference(startTime);
          
          NewrelicMobile.instance.recordMetric(
            'Custom/WidgetBuild/${widget.widgetName}',
            buildTime.inMicroseconds.toDouble()
          );
        });
        
        return false;
      },
      child: widget.child,
    );
  }
}

// 使用例
class MyExpensiveWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return PerformanceMonitoredWidget(
      widgetName: 'MyExpensiveWidget',
      child: Column(
        children: [
          // 重い処理を含むウィジェット
        ],
      ),
    );
  }
}

import 'package:flutter/scheduler.dart';
import 'package:newrelic_mobile/newrelic_mobile.dart';

class FrameRateMonitor {
  static FrameRateMonitor? _instance;
  static FrameRateMonitor get instance => _instance ??= FrameRateMonitor._();
  
  FrameRateMonitor._();
  
  final List<Duration> _frameTimes = [];
  late Ticker _ticker;
  
  void startMonitoring() {
    _ticker = Ticker((elapsed) {
      _frameTimes.add(elapsed);
      
      // 直近100フレームの平均FPSを計算
      if (_frameTimes.length >= 100) {
        _calculateAndReportFPS();
        _frameTimes.clear();
      }
    });
    
    _ticker.start();
  }
  
  void stopMonitoring() {
    _ticker.dispose();
  }
  
  void _calculateAndReportFPS() {
    if (_frameTimes.length < 2) return;
    
    final totalDuration = _frameTimes.last - _frameTimes.first;
    final fps = (_frameTimes.length / totalDuration.inSeconds);
    
    NewrelicMobile.instance.recordMetric('Custom/FrameRate', fps);
    
    // 60FPS未満の場合はイベントとして記録
    if (fps < 55) {
      NewrelicMobile.instance.recordCustomEvent('LowFrameRate', {
        'fps': fps,
        'frameCount': _frameTimes.length,
        'duration': totalDuration.inMilliseconds,
      });
    }
  }
}