New Relic GCP統合設定とCloud Operations連携 ​

# vm-template.py
def GenerateConfig(context):
    resources = []
    
    # Startup script with New Relic agent installation
    startup_script = '''#!/bin/bash
    
# Variables
NEW_RELIC_LICENSE_KEY="{license_key}"
PROJECT_ID=$(curl -s -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/project/project-id")
INSTANCE_NAME=$(curl -s -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/name")
ZONE=$(curl -s -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/zone" | cut -d'/' -f4)

# Install New Relic Infrastructure Agent
curl -fsSL https://download.newrelic.com/infrastructure_agent/gpg/newrelic-infra.gpg | apt-key add -
echo "deb https://download.newrelic.com/infrastructure_agent/linux/apt focal main" | tee /etc/apt/sources.list.d/newrelic-infra.list
apt-get update
apt-get install newrelic-infra -y

# Configuration
cat > /etc/newrelic-infra.yml << EOF
license_key: $NEW_RELIC_LICENSE_KEY
display_name: $INSTANCE_NAME
custom_attributes:
  gcp_project_id: $PROJECT_ID
  gcp_zone: $ZONE
  environment: production
  deployment_method: deployment_manager
EOF

systemctl enable newrelic-infra
systemctl start newrelic-infra
'''.format(license_key=context.properties['newRelicLicenseKey'])
    
    # VM instance configuration
    vm_instance = {
        'name': context.env['name'],
        'type': 'compute.v1.instance',
        'properties': {
            'zone': context.properties['zone'],
            'machineType': 'zones/{}/machineTypes/{}'.format(
                context.properties['zone'],
                context.properties['machineType']
            ),
            'disks': [{
                'deviceName': 'boot',
                'type': 'PERSISTENT',
                'boot': True,
                'autoDelete': True,
                'initializeParams': {
                    'diskName': context.env['name'] + '-disk',
                    'sourceImage': context.properties['sourceImage'],
                    'diskSizeGb': '20'
                }
            }],
            'networkInterfaces': [{
                'network': 'global/networks/{}'.format(context.properties['network']),
                'accessConfigs': [{
                    'name': 'External NAT',
                    'type': 'ONE_TO_ONE_NAT'
                }]
            }],
            'metadata': {
                'items': [{
                    'key': 'startup-script',
                    'value': startup_script
                }]
            },
            'tags': {
                'items': context.properties.get('tags', [])
            },
            'serviceAccounts': [{
                'email': 'default',
                'scopes': [
                    'https://www.googleapis.com/auth/compute.readonly',
                    'https://www.googleapis.com/auth/monitoring.read',
                    'https://www.googleapis.com/auth/logging.write'
                ]
            }]
        }
    }
    
    resources.append(vm_instance)
    
    # Firewall rule for New Relic monitoring
    firewall_rule = {
        'name': context.env['name'] + '-firewall',
        'type': 'compute.v1.firewall',
        'properties': {
            'direction': 'EGRESS',
            'priority': 1000,
            'targetTags': ['newrelic-monitored'],
            'allowed': [{
                'IPProtocol': 'tcp',
                'ports': ['443']
            }],
            'destinationRanges': ['0.0.0.0/0']
        }
    }
    
    resources.append(firewall_rule)
    
    return {'resources': resources}

# Cloud Function - Cloud Trace to New Relic forwarder
import json
import os
import requests
from google.cloud import trace_v1
from datetime import datetime, timedelta

def forward_traces_to_newrelic(request):
    """
    Cloud TraceからNew Relicにトレースを転送する関数
    """
    
    # New Relic設定
    newrelic_endpoint = 'https://trace-api.newrelic.com/trace/v1'
    license_key = os.environ.get('NEW_RELIC_LICENSE_KEY')
    
    if not license_key:
        return {'error': 'NEW_RELIC_LICENSE_KEY not set'}, 400
    
    try:
        # Cloud Trace クライアント
        client = trace_v1.TraceServiceClient()
        project_id = os.environ.get('GCP_PROJECT', os.environ.get('GOOGLE_CLOUD_PROJECT'))
        
        # 過去5分間のトレースを取得
        end_time = datetime.utcnow()
        start_time = end_time - timedelta(minutes=5)
        
        # トレース取得のリクエスト
        request_body = {
            "project_id": project_id,
            "view": trace_v1.ListTracesRequest.ViewType.COMPLETE,
            "page_size": 100,
            "start_time": start_time,
            "end_time": end_time
        }
        
        # トレース一覧を取得
        traces = client.list_traces(request=request_body)
        
        # New Relicに送信するデータ形式に変換
        spans = []
        for trace in traces:
            for span in trace.spans:
                span_data = {
                    'id': span.span_id,
                    'trace.id': trace.trace_id,
                    'timestamp': int(span.start_time.timestamp() * 1000),
                    'duration': int((span.end_time.timestamp() - span.start_time.timestamp()) * 1000),
                    'name': span.display_name.value,
                    'attributes': {
                        'gcp.project_id': project_id,
                        'gcp.trace_id': trace.trace_id,
                        'gcp.span_id': span.span_id,
                        'gcp.parent_span_id': span.parent_span_id,
                        'gcp.span_kind': str(span.kind),
                        'service.name': 'gcp-trace-integration'
                    }
                }
                
                # ラベルの追加
                for key, value in span.labels.items():
                    span_data['attributes'][f'gcp.label.{key}'] = value
                
                spans.append(span_data)
        
        # New Relicに送信
        headers = {
            'Content-Type': 'application/json',
            'Api-Key': license_key
        }
        
        payload = {
            'common': {
                'attributes': {
                    'service.name': 'gcp-trace-integration',
                    'service.version': '1.0.0'
                }
            },
            'spans': spans
        }
        
        response = requests.post(
            newrelic_endpoint,
            headers=headers,
            json=payload
        )
        
        return {
            'status': 'success',
            'traces_processed': len(spans),
            'response_status': response.status_code
        }
        
    except Exception as e:
        print(f'Error processing traces: {str(e)}')
        return {'error': str(e)}, 500

# Cloud Monitoring カスタムメトリクスをNew Relicに送信
from google.cloud import monitoring_v3
import requests
import json
import os

def sync_custom_metrics():
    """
    Cloud Monitoring カスタムメトリクスをNew Relicに同期
    """
    
    # クライアント初期化
    client = monitoring_v3.MetricServiceClient()
    project_name = f"projects/{os.environ['GCP_PROJECT']}"
    
    # New Relic設定
    newrelic_endpoint = 'https://metric-api.newrelic.com/metric/v1'
    license_key = os.environ['NEW_RELIC_LICENSE_KEY']
    
    # カスタムメトリクスの取得
    metrics = client.list_metric_descriptors(name=project_name)
    
    for metric in metrics:
        if metric.type.startswith('custom.googleapis.com/'):
            # メトリクスデータの取得と変換
            # ...変換ロジック...
            
            # New Relicに送信
            headers = {
                'Content-Type': 'application/json',
                'Api-Key': license_key
            }
            
            # 送信処理
            response = requests.post(newrelic_endpoint, headers=headers, json=metric_data)