AWS Lambda向けサーバーレスモニタリングを有効にする

AWS Lambda 向けのサーバーレスモニタリングは、Lambda 関数の綿密なパフォーマンスモニタリングを提供します。この機能を有効にして使用する方法を学ぶために読んでください。

この機能を使用すると、AWS の料金が発生する場合があります。詳細については、Lambda モニタリング要件を参照してください。

Lambda監視のしくみ

Lambdaモニタリングを有効にする前に、Lambda関数からNew Relicへのデータフローについて理解しておくとよいでしょう。

AWS LambdaのNew Relic監視のアーキテクチャ - 図
Lambda関数からNew Relicへのデータフローを示した図表。

Lambdaモニタリングが有効な場合、次のようにデータはLambda関数からNew Relicに移動します。

  1. Lambda関数は、当社のコードでインストゥルメントされています。
  2. CloudWatchは、Lambdaのログデータを収集し、New Relicのlog-ingestion Lambdaに送信します。
  3. log-ingestion Lambda はそのデータをNew Relicに送信します。

有効化の手順の概要

すでにNew Relicアカウントをお持ちでNode.jsまたはPythonを使用している場合は、自動化されたインストーラを使用することをお勧めします。

自動化されたインストーラを使用していない場合、次の手順を完了してモニタリングのセットアップを行います:

  1. CLI ツールをインストールする(推奨)
  2. AWSと New Relic を接続する(推奨)
  3. ご利用のLambdaインストゥルメンテーションを有効化する(推奨)
  4. New Relic にC loudWatch ログをストリーミングする(推奨)

ステップ1。newrelic-lambda-cliツールをインストールする

ステップ2~4にかけて使用したコマンドラインインタフェース(CLI)ツールを用意しました。CLIは、作業の一部を簡略化しながらも、こうしたステップを手動で実行できるためお勧めです。

インストール前にその仕組みを理解したい場合は、ステップ2、ステップ3(オプション2)、そしてステップ4でCLIツールが行う手動の手順を参照してください。また、CLIドキュメンテーションをGitHubで確認することもできます。手動インストールを希望する場合は、ステップ2 AWSをNew Relicに接続するに進みます。

CLIの要件

CLIツールを使用するには、以下が必要となります:

  • Python 3.3 以降
  • AWS CLI
  • ユーザーまたはInfrastructureマネージャーのアドオンロールを備えた管理者でなくてはいけません。
  • AWSアカウントには、IAMリソース(ロールとポリシー)およびLambda関数を作成する権限が必要です。こうしたリソースは、CloudFormationスタックを使用して作成されるため、このスタックを作成する権限が必要となります。カスタム方針の設定を含む権限の詳細に関しては、この折り畳みを表示してください:

    AWS権限の詳細
    Resource: *
    Actions:
        "cloudformation:CreateChangeSet",
        "cloudformation:CreateStack",
        "cloudformation:DescribeStacks",
        "cloudformation:ExecuteChangeSets",
        "iam:AttachRolePolicy",
        "iam:CreateRole",
        "iam:GetRole",
        "iam:PassRole",
        "lambda:AddPermission",
        "lambda:CreateFunction",
        "lambda:GetFunction",
        "logs:DeleteSubscriptionFilter",
        "logs:DescribeSubscriptionFilters",
        "logs:PutSubscriptionFilter"
       "s3:GetObject"
        "serverlessrepo:CreateCloudFormationChangeSet"
    
    Resource: "arn:aws:serverlessrepo:us-east-1:463657938898:applications/NewRelic-log-ingestion"
    Actions:
        "serverlessrepo:CreateCloudFormationTemplate"
        "serverlessrepo:GetCloudFormationTemplate"
    

    CLIの実行で使用するAWSアカウントに、これらすべての権限があることを確認してください。

    AWSアカウント権限に制限があり、CLIを使用できない場合は、手動管理されたIAMポリシーを使用するオプションもあります。このポリシーは、最低でも以下の権限を必要とします:

    Resource: "*"
    Action:      
      "cloudwatch:GetMetricStatistics"
      "cloudwatch:ListMetrics"
      "cloudwatch:GetMetricData"
      "lambda:GetAccountSettings"
      "lambda:ListFunctions"
      "lambda:ListAliases"
      "lambda:ListTags"
      "lambda:ListEventSourceMappings"
    

    これらの権限は、最小要件となります。当社では、AWSをInfrastructureのモニタリングに接続するにある通り、マネージドReadOnlyAccessポリシーの付与を推奨しています。

CLIインストレーション

以下の方法で、CLIツールをインストールしてください:

  1. 必ず、New RelicとAWSアカウントの両方の必要な権限があることを確認してください。
  2. コマンドラインから、以下を実行してください。
     pip install newrelic-lambda-cli 

Python 2.7をインストール済みの場合は、上記コマンドでpip3を使用する必要があるかもしれません。CLIを使用するには、Python 3.3以上が必要です。

ステップ2。AWSをNew Relicに接続する

Lambdaモニタリングを有効にするには、このステップならびにステップ3~4を実施する必要があります。

このステップでは、AWSをNew Relicに接続することで、インストゥルメントされたデータをNew Relicに送信するnewrelic-log-ingestion Lambda関数を作成します。CLIツールを使用するか、手動でステップを進めることができます。

CLIツールを使用する

CLIを使用すると、オプションのステップと必須のステップがそれぞれ1つずつあります:

  1. オプション:複数のAWSプロファイルまたは複数のリージョンを使用している場合は、AWSの環境変数を設定すると良いかもしれません:

    AWSの環境変数に関する説明

    リージョンの設定
    リージョンを設定するには、この 環境変数 を使用してデフォルトのリージョンをオーバーライドしてください:

    export AWS_DEFAULT_REGION=MY_REGION # us-west-2, for example
    

    CLIツールもまた、これを--aws-region経由でコマンドごとにパスできます。

    プロファイルの設定

    AWSプロファイルが複数あり、デフォルトを使用しない場合、AWS_PROFILE環境変数を使用して別のプロファイル名を設定します。プロファイルが適切に設定されていることを確認します(デフォルトの地域を含む)。例:

    export AWS_PROFILE=MY_PROFILE
    
  2. CLI toolを使用して、以下のコマンドを実行してください:

    newrelic-lambda integrations install --nr-account-id YOUR_ACCOUNT_ID \
    --linked-account-name YOUR_LINKED_ACCOUNT_NAME \
    --nr-api-key YOUR_NR_API_KEY
    

    このコマンドは:

    • ご使用のAWSアカウントをNew Relicに接続します。
    • インストゥルメントされたデータをNew Relicに送信する、newrelic-log-ingestion Lambdaをインストールします。

    さらに詳しく:

    • これは、米国リージョンをデフォルト設定にします。アカウントが欧州地域である場合、次の引数を追加してください: --nr-region "eu"。複数のAWSリージョンで引数をインストゥルメントしている場合、このコマンドは --aws-region 引数を使用して各リージョンで実行する必要があります。

    • YOUR_LINKED_ACCOUNT_NAME は、New Relic にリンクする新しいAWSアカウントまたは AWS Lambda モニタリング インテグレーションを設定するときにリンクしたAWSアカウントの名前です。
    • YOUR_NR_API_KEYは、あなたのパーソナルAPIキー(REST APIキーではない)を指しています。

    • APIキーおよびその他の引数に関しては、LambdaモニタリングGitHubリポジトリを参照してください。

手動の手順

CLIツールが実行する手動の手順は以下のとおりです:

AWSをNew Relicに接続する

newrelic-lambda integrationコマンドは、Lambdaを含むAWSアカウントをNew Relicに接続します。すでにAWSインテグレーションの1つをインストールしている場合、アカウントをNew Relicにリンクしてください。それでこのセクションを省略できます。

この接続を手動で確立するには、AWSをInfrastructureのモニタリングに接続するの指示に従ってください。

log-ingestion Lambdaを設定

newrelic-lambda integrationコマンドは、newrelic-log-ingestion Lambdaを設定します。このLambdaは、Lambda関数が生成したログを取得し、そのログをNew Relicにプッシュします。これを手動で行っている場合、このLambdaを希望の地域について設定する必要があります。

CLIはデフォルトで、Lambdaをすべての地域で設定します。

Lambdaを手動で設定するには、AWSサーバーレスアプリケーションリポジトリを使用します。このリポジトリに、newrelic-log-ingestion Lambdaが保存されます。このリポジトリは、サーバーレスコミュニティの開発者や会社、パートナーが公開したサーバーレスアプリケーションをまとめたものです。このリポジトリを使用して、開発者はLambda関数コードを顧客と共有し、顧客は対応するアプリケーションのLambda関数を検索してデプロイできます。各アプリケーションは、使用したAWSリソースを定義するAWSサーバーレスアプリケーションモデル(SAM)テンプレートでパッケージ化されます。

AWSサーバーレスアプリケーションリポジトリを使用してLambdaを手動で設定するには:

  1. AWSコンソールからLambdaセクションに移動し、関数を作成を選択し、サーバーレスアプリケーションリポジトリを選択します。
  2. newrelicを検索し、newrelic-log-ingestion Lambdaを検索します。Lambdaドキュメントの指示に従い、デプロイします。SAMテンプレートがLambdaを構築します。
  3. AWSコンソールの環境変数セクションで、LICENSE_KEY環境変数をNew Relicライセンスキーに設定します。注: 複数のアカウントまたはマスターとサブアカウントのヒエラルキーがある場合は、必ずAWSに接続したものと同じアカウントに相当するライセンスキーを使用してください。
  4. オプション:すべてのログのNew Relic Logsへのストリーミングを行う場合、LOGGING_ENABLED環境変数をtrueに設定します。この詳細に関しては、全てのログをストリーミングするを参照してください。

ステップ3。Lambdaインストゥルメンテーションを有効にする

このステップによってお客様のLambda機能のインストゥルメンテーションが可能になり、詳細なモニタリングとアラート機能ができるようになります。当社のインストゥルメンテーションは、Lambdaのパフォーマンスへの影響を最小限に抑えられるように設計されています。

Node.jsまたはPythonを使用している場合は、最初の2つのオプションが推奨されます。

オプション#1:Serverless Frameworkプラグイン(Node.jsおよびPython)を使用してください

要件

機能

(上記の)要件に適合している場合、当社のServerless Frameworkプラグインを使用できます。これによって、コードの変更が要求されることなくAWS Lambda Layerを機能に追加できます。

  • Node.jsおよびPythonランタイムのサポート
  • Lambdaインストゥルメンテーションを有効にするには、コードの変更は不要です。
  • 単一レイヤを用いてAPMエージェント機能を有効化
  • CloudWatchサブスクリプションフィルターを自動で構成
  • 再デプロイに役立つコードベースにレイヤーを取得します

インストール

当社のServerless Frameworkプラグインをインストールするには:

  1. インストールオプションを選択してください:
    • NPM:
       npm install --save-dev serverless-newrelic-lambda-layers 
    • yarn:
       yarn add --dev serverless-newrelic-lambda-layers 
  2. プラグインをお客様のserverless.ymlへ追加してください:
     plugins: - serverless-newrelic-lambda-layers 
  3. お客様のアカウントIDを入手し、serverless.ymlに入力します:
     custom: newRelic: accountId: YOUR_ACCOUNT_ID 
  4. それをデプロイしてください:
     sls deploy 

ステップ4 CloudWatchログを設定するをスキップできます。これは、Serverless Frameworkのプラグインによってディプロイ時に自動的に完了します。

次のステップに進んでください。

オプション#2: Lambda Layer(Node.jsおよびPython)を当社のCLIに追加

Node.jsおよびPythonにおいてのみ利用可能です。他の言語の場合、手動インストゥルメンテーションを参照してください。

Serverless Frameworkをお持ちでなく、関数を頻繁に再デプロイする予定がない場合は、CLIを使用してLambda Layer を手動で追加できます。

  1. まだの場合は、CLIをインストールしてください:
     pip install newrelic-lambda-cli
  2. 利用可能な関数を一覧表示:
    newrelic-lambda functions list

    オプション-f not-installedを渡し、どの関数がまだインストゥルメントされていないかを一覧表示します。

  3. レイヤーを関数に追加:
     newrelic-lambda layers install --function FUNCTION_NAME --nr-account-id NEW_RELIC_ACCOUNT_ID

次に、CloudWatchを設定してログをNew Relicに送信します

オプション#3: 当社のLambda Layer(Node.jsおよびPython)を手動で追加

Node.jsおよびPythonにおいてのみ利用可能です。他の言語の場合、手動インストゥルメンテーションを参照してください。

Serverless Frameworkをお持ちでない場合、Lambda Layerを手動で追加できます。

  1. お客様のランタイムとリージョンに一致するレイヤを検索します。
  2. 最新バージョンのAmazonリソースネーム(ARN)をコピーし、お客様の機能のAWS Lambdaコンソールにこれを追加します。
  3. お客様の機能向けのコンソールにおいて新しく追加されたレイヤを示す機能ハンドラを更新します。
    • Python: newrelic_lambda_wrapper.handler
    • Node:newrelic-lambda-wrapper.handler
  4. これらの環境変数をLambdaコンソールに追加します。
    • NEW_RELIC_ACCOUNT_ID: お客様のアカウントID
    • NEW_RELIC_LAMBDA_HANDLER: 初期ハンドラへのパス

Node 8を使用していて、Lambda can't find file エラーメッセージが表示される場合は、次の折り畳みを表示してください:

Node 8の "can't find file" エラーに関するトラブルシューティング

Node 8を使用していて、Lambda can't find the file newrelic-lambda-wrapper.js メッセージが表示された場合、Nodeランタイムが /opt/nodejs/node_modules においてnewrelic-lambdaモジュールのNPM_PATH を解決していないことが予想されます。以下のステップを経て、問題を修正してください:

  • プロジェクトルートで newrelic-wrapper-helper.js スクリプトを作成します。
  • このスクリプトは、module.exports = require('newrelic-lambda-wrapper');でなくてはいけません。(このスクリプトには、以上の内容のみを含める。)
  • レイヤー宣言のハンドラーを newrelic-lambda-wrapper.handlerにアップデートします。

次に、CloudWatchを設定してログをNew Relicに送信します

オプション#4: 手動でLambdaコードをインストゥルメントする(Go、Java、.Net Core、Node.js、Python)

前述のオプション のいずれも機能しない場合、Lambdaコードを手動でインストゥルメントできます。言語を選択してください:

Go

Go-language Lambdaをインストゥルメントするには:

  1. Goエージェントパッケージをダウンロードし、関数と同じディレクトリに置きます。

  2. エージェントのインストール:go get -u github.com/newrelic/go-agent

  3. Lambdaコードで、コンポーネントをインポートし、アプリケーションを作成し、Lambdaの起動方法を更新します。インストゥルメントされたLambdaの例については、GitHubリポジトリをご覧ください。
  4. オプション:RecordCustomEvent APIを使用して、Lambda呼び出しに関連付けるカスタムイベントを追加します。例えば:

    func handler(ctx context.Context) {
    	if txn := newrelic.FromContext(ctx); nil != txn {
    		txn.Application().RecordCustomEvent("MyEvent", map[string]interface{}{
    			"zip": "zap",
    		})
    	}
    	fmt.Println("hello world!")
    }
    
  5. Lambda関数を構築して圧縮し、AWSにアップロードします。

    圧縮とアップロートについての推奨

    Lambdaの圧縮とアップロードについての推奨は次のとおりです。

    1. Linuxでの実行用のバイナリを構築します。これにより、mainと呼ばれるバイナリファイルが作成されます。次のものを使用できます。
       $ GOOS=linux go build -o main 
    2. 次のものを使用して、バイナリをデプロイパッケージに圧縮します。

      $ zip deployment.zip main
      
    3. AWS LambdaコンソールまたはAWS CLIのいずれかを使用して、zipファイルをAWSにアップロードします。(バイナリ構築の間に付けられた名前と同じにするため)ハンドラーの名前をmainにします。

  6. 次の環境変数はLambdaモニターの機能には不要ですが、Lambda機能をディストリビューティッド(分散)トレーシングに含める場合は必要です。ディストリビューティッド(分散)トレーシングを有効にするには、AWSコンソールで次の環境変数を設定します。
    • NEW_RELIC_ACCOUNT_ID。お客様のアカウントID
    • NEW_RELIC_TRUSTED_ACCOUNT_KEY これは、お客様のアカウントIDでもあります。アカウントがサブアカウントの場合、これはroot/親アカウントのアカウントIDとなります。
  7. オプション:ログ作成を設定するには、Go agentのログ作成をご覧ください。
  8. 少なくとも1回Lambdaを呼び出します。これにより、CloudWatchロググループが作成されます。次のステップを行うには、このグループが必要です。

ラッパーはLambda実行についてのデータを収集し、JSONメッセージを生成し、CloudWatchログに記録します。次に、CloudWatchを設定してそのログをNew Relicに送信します

Java

JavaでのAWS Lambdaのモニタリングでは、APM Javaエージェントは使用しません。代わりに、次の2つのOpenTracing依存関係を使用します。

  • AWS Lambda OpenTracing Java SDK: AWS Lambda RequestHandlerおよびRequestStreamHandlerのOpenTracingインストゥルメンテーション。
  • AWS Lambda OpenTracing Tracer:OpenTracing Tracerの実装は、AWS Lambdaをモニターするように設計されています。スパンやエラーイベント、トランザクションイベント、エラートレースを生成し、ディストリビューティッド(分散)トレーシングをサポートします。

サポート対象の OpenTracing バージョン

Java Lambdaをインストゥルメントするには:

  1. プロジェクトのbuild.gradleファイルに、OpenTracing AWS Lambda TracerとAWS Lambda OpenTracing SDK依存関係を含めます:

    dependencies {
           compile("com.newrelic.opentracing:java-aws-lambda:2.1.0")
           compile("com.newrelic.opentracing:newrelic-java-lambda:2.1.1")
           compile("io.opentracing:opentracing-util:0.33.0")
    }
    
  2. Java Lambdaの例に示されたようにAWS Lambda RequestHandlerインタフェースを実装し、doHandleRequestメソッドを上書きします。

  3. doHandleRequestメソッドで、LambdaTracing.instrument(...)を呼び出します。Lambda関数の実行をトレースするルートスパンを作成するためのAPI。このAPIでは、Lambda関数のビジネスロジックも定義します。

  4. Java Lambdaの例に示されたように、LambdaTracer.INSTANCEをOpenTracing Globalトレーサーとして登録します。

  5. ZIPデプロイパッケージを作成し、AWS Lambdaにアップロードします。または、その他の方法でディプロイします。
  6. AWS Lambdaコンソールで、ハンドラーを設定します。Java Lambdaの例で、ハンドラーはcom.handler.example.MyLambdaHandler::handleRequestとなります。handleRequestが前提となっているため、also use com.handler.example.MyLambdaHandlerも使用できます。

  7. 以下の AWSコンソール環境変数は、Lambda機能をディストリビューティッド(分散)トレーシングに含める場合は必要です。これが推奨されます。
    • NEW_RELIC_ACCOUNT_ID。お客様のアカウントID
    • NEW_RELIC_PRIMARY_APPLICATION_ID。これは、お客様のアカウントIDでもあります。
    • NEW_RELIC_TRUSTED_ACCOUNT_KEY これは、お客様のアカウントIDでもあります。アカウントがサブアカウントの場合、これはroot/親アカウントのアカウントIDである必要があります。
  8. オプション:Lambdaコンソールで、この環境変数を追加してデバッグロギングを有効にします:NEW_RELIC_DEBUGtrueです。
  9. 少なくとも1回Lambdaを呼び出します。これにより、CloudWatchロググループが作成されます。次のステップを行うには、このグループが必要です。

ラッパーはLambda実行についてのデータを収集し、JSONメッセージを生成し、CloudWatchログに記録します。次に、CloudWatchを設定してそのログをNew Relicに送信します

次のような一般的な使用例を示す完全なプロジェクトのAWS Lambdaディストリビューティッド(分散)トレーシングの例をご覧ください。

  • Lambda関数間のディストリビューティッド(分散)トレーシング
  • 手作業でのスパン作成(別名カスタムインストゥルメンテーション)
  • 外部コールのトレース
  • カスタムアトリビュート(別名タグ)のスパンへの追加
.NET Core

.NET CoreベースのAWS Lambda関数の監視は弊社の標準的.NET Core APMエージェントを使用しません。代わりに、NuGetパッケージを使用します。

ご利用の.NET Core Lambdaをインストゥルメントするには、

  1. ご自分のLambda関数プロジェクトで、NewRelic.OpenTracing.AmazonLambda.Tracer NuGetパッケージをインストールしてください。

    注: NewRelic.OpenTracing.AmazonLambda.Tracer は、Amazon.Lambda.APIGatewayEvent NuGet パッケージのバージョン 1.2.0 以降に依存しています。環境がすでに下位バージョンの Amazon.Lambda.APIGatewayEvent を使用している場合、New Relic パッケージは System.MissingMethodException などのエラーを生成する可能性があります。

  2. NuGetパッケージとOpenTracingユーティリティをインポートします:

    using OpenTracing.Util;
    using NewRelic.OpenTracing.AmazonLambda;
  3. 例で示されたように、ご利用の機能を以下のようにインストゥルメントする。
     public class Function { static Function() { // Register The NewRelic Lambda Tracer Instance GlobalTracer.Register(NewRelic.OpenTracing.AmazonLambda.LambdaTracer.Instance); } public object FunctionWrapper(ILambdaContext context) { // Instantiate NewRelic TracingWrapper and pass your FunctionHandler as // an argument return new TracingRequestHandler().LambdaWrapper(FunctionHandler, context); } /// <summary> /// A simple function that takes a string and does a ToUpper /// </summary> /// <param name="input"></param> /// <param name="context"></param> /// <returns></returns> public object FunctionHandler(ILambdaContext context) { ... } } 

    FunctionWrapperに渡される引数は、FunctionHandlerの署名と一致する必要があります。

    ハンドラー関数がタスクを返す場合、Lambdaラッパーは返されたタスクを完了するまでブロックします。そのため、持続時間を計測でき、例外がある場合それを把握できます。また、APIGatewayProxyFunctionから継承することもできます。

    例については、以下をご覧ください。

    非同期ハンドラー関数
    public override Task<int> FunctionHandlerAsync(ILambdaContext lambdaContext)
    {
      // This call will block by calling task.Result 
      Task<int> task = new TracingRequestHandler().LambdaWrapper(
                                       ActualFunctionHandlerAsync, lambdaContext);
      return task;
    }
    
    public Task<APIGatewayProxyResponse> ActualFunctionHandlerAsync(ILambdaContext 
                                                                    lambdaContext)
    { // Function can make other async operations here
      ... 
    }
    APIGatewayProxyFunctionからの継承
    public class LambdaFunction : APIGatewayProxyFunction
    {
      static LambdaFunction()
      {
        // Register The NewRelic Lambda Tracer Instance
        OpenTracing.Util.GlobalTracer.Register(NewRelic.OpenTracing.AmazonLambda.LambdaTracer.Instance);
      }
    
      public override Task<APIGatewayProxyResponse> FunctionHandlerAsync(APIGatewayProxyRequest request, ILambdaContext lambdaContext)
      {
        Task<APIGatewayProxyResponse> task = new TracingRequestHandler().LambdaWrapper(ActualFunctionHandlerAsync, request, lambdaContext);
        return task;
      }
    
      public Task<APIGatewayProxyResponse> ActualFunctionHandlerAsync(APIGatewayProxyRequest request, ILambdaContext lambdaContext)
      {
        return base.FunctionHandlerAsync(request, lambdaContext);
      }
    }
    
  4. SQSおよびSNSにおけるオプション:.NET Lambda Tracerのバージョン1.0以降、ディストリビューティッド(分散)トレーシングサポートがSQSとSNSについて追加されています。SQSまたはSNSにおいてディストリビューティッド(分散)トレーシングを有効にするには、このステップの項目を完了させるとともに、これに続くステップにおいて環境変数を設定する必要があります。

    SQSおよびSNSにおいてディストリビューティッド(分散)トレーシングのサポートを有効にすると、SQSとSNSの両方において自動インストゥルメンテーションが無効になり、それらのインストゥルメントに向けてこれらのwrapperの使用が要求されることになります。

    1. NEW_RELIC_USE_DT_WRAPPER環境変数をtrueに設定してください。

    2. SQSおよびSNSコールをインストゥルメントするには、規定のwrapperを使用する必要があります。

      SQS Wrapperの使用

      SQS wrapperは以下の手法のラッピングをサポートします。

      • Amazon.SQS.AmazonSQSClient.SendMessageAsync(...)

      • Amazon.SQS.AmazonSQSClient.SendMessageBatchAsync(...)

      // SQS Client
      AmazonSQSClient client = new AmazonSQSClient("AWS_SECRET_ACCESS_KEY", AWS_REGION);
      
      
      // SendMessageRequest
      SendMessageRequest sendRequest = new SendMessageRequest("QUEUE_URI_STRING", "An SQS Message");
      Task<SendMessageResponse> responseOne = SQSWrapper.WrapRequest(client.SendMessageAsync, sendRequest);
      
      
      // String-based
      Task<SendMessageResponse> responseTwo = SQSWrapper.WrapRequest(client.SendMessageAsync, "QUEUE_URI_STRING", "Another SQS Message");
      
      
      // SendMessageBatchRequest
      List<SendMessageBatchRequestEntry> batchEntries = new List<SendMessageBatchRequestEntry>();
      batchEntries.Add(new SendMessageBatchRequestEntry("id1", "First SQS Message"));
      batchEntries.Add(new SendMessageBatchRequestEntry("id2", "Second SQS Message"));
      batchEntries.Add(new SendMessageBatchRequestEntry("id3", "Third SQS Message"));
      SendMessageBatchRequest sendBatchRequest = new SendMessageBatchRequest(QUEUE_URI, batchEntries);
      Task<SendMessageBatchResponse> response = SQSWrapper.WrapRequest(client.SendMessageBatchAsync, sendBatchRequest);
      
      
      // SendMessageBatchRequestEntry List
      List<SendMessageBatchRequestEntry> moreBatchEntries = new List<SendMessageBatchRequestEntry>();
      batchEntries.Add(new SendMessageBatchRequestEntry("id4", "Fourth SQS Message"));
      batchEntries.Add(new SendMessageBatchRequestEntry("id5", "Fifth SQS Message"));
      batchEntries.Add(new SendMessageBatchRequestEntry("id6", "Sixth SQS Message"));
      Task<SendMessageBatchResponse> response = SQSWrapper.WrapRequest(client.SendMessageBatchAsync, moreBatchEntries);
                          
      SNS Wrapperの使用

      SNS wrapperは以下の手法のラッピングをサポートします。

      • Amazon.SimpleNotificationService.AmazonSimpleNotificationServiceClient.PublishAsync(...)

      // SNS Client
      AmazonSimpleNotificationServiceClient client = new Amazon.SimpleNotificationService.AmazonSimpleNotificationServiceClient("AWS_SECRET_ACCESS_KEY", AWS_REGION);
      
      
      // PublishRequest - Phone Number
      PublishRequest phonePublishRequest = new PublishRequest();
      phonePublishRequest.PhoneNumber = +1XXX5555100;
      phonePublishRequest.Message = "An SNS Message for phones";
      Task<PublishResponse> phoneResponse = SNSWrapper.WrapRequest(client.PublishAsync, phonePublishRequest);
      
      
      // PublishRequest - ARN
      PublishRequest publishRequest = new PublishRequest("TOPIC_ARN", "An SNS Message");
      Task<PublishResponse> publishResponse = SNSWrapper.WrapRequest(client.PublishAsync, publishRequest);
      
      
      // String-based without subject
      Task<PublishResponse> ResponseOne = SNSWrapper.WrapRequest(client.PublishAsync, "TOPIC_ARN", "Another SNS Message");
      
      
      // String-based with subject
      Task<PublishResponse> ResponseTwo = SNSWrapper.WrapRequest(client.PublishAsync, "TOPIC_ARN", "Yet Another SNS Message", "A Subject");
                          
  5. 次の環境変数はLambdaモニターの機能には不要ですが、Lambda機能をディストリビューティッド(分散)トレーシングに含める場合は必要です。ディストリビューティッド(分散)トレーシングを有効にするには、AWS Lambdaコンソールで次の環境変数を設定します。
    • NEW_RELIC_ACCOUNT_ID: LambdaがレポートするアカウントID
    • NEW_RELIC_TRUSTED_ACCOUNT_KEY: これは、アカウントIDでもあります。アカウントがサブアカウントの場合、これはroot/親アカウントのアカウントIDである必要があります。
  6. ラッパー関数 (上記の例ではFunctionWrapper)が関数ハンドラーとして設定されていることを確認してください。
  7. 少なくとも1回Lambdaを呼び出します。これにより、CloudWatchロググループが作成されます。次のステップを行うには、このグループが必要です。

ラッパーはLambda実行についてのデータを収集し、JSONメッセージを生成し、CloudWatchログに記録します。次に、CloudWatchを設定してそのログをNew Relicに送信します

Node.js

Node.js Lambdaをインストゥルメントするには:

  1. Node.jsエージェントパッケージをダウンロードし、関数と同じディレクトリに配置し、エージェントがnode_modulesディレクトリで依存関係としてインストールされていることを確認します。Node Package Managerを使用します:

    npm install newrelic --save
    
  2. AWS SDKモジュールをNode.jsエージェントとともにインストールする:

    npm install @newrelic/aws-sdk --save
    
  3. Lambdaコードで、ファイルの先頭でエージェントモジュールとAWS SDKを求め、ハンドラー関数にラップします。例えば:

    const newrelic = require('newrelic');
    require('@newrelic/aws-sdk');
    
    <Other module loads go under the two require statements above>
    
    module.exports.handler = newrelic.setLambdaHandler((event, context, callback) => {
      // This is your handler function code
      console.log('Lambda executed');
      callback();
    });
    
  4. オプション:recordCustomEvent APIを使用して、Lambdaにカスタムイベントを追加することもできます。例えば:

    module.exports.handler = newrelic.setLambdaHandler((event, context, callback) => {
      newrelic.recordCustomEvent(‘MyEventType’, {foo: ‘bar’}); 
    
      console.log('Lambda executed');
      callback();
    });
    
  5. Lambda関数とNode.jsエージェントフォルダを一緒に圧縮します。要件および推奨:

    • New Relicエージェントフォルダに入っていないNew Relicファイルは、含める必要はありません。

    • Lambda関数ファイル名がたとえばlambda_function.nodeの場合、zipファイルの名前をlambda_function.zipとすることが推奨されます。tarballは使用しないでください。

    • Lambdaと関連モジュールはすべて、zipファイルのルートディレクトリに入っている必要があります。つまり、ファイルを含むファイルを圧縮するとうまくいきません。

  6. 圧縮したファイルを、AWS Lambdaアカウントにアップロードします。
  7. AWSコンソールで、次の環境変数を設定します:

    • NEW_RELIC_NO_CONFIG_FILE。設定ファイルを使用していない場合、trueに設定します。
    • NEW_RELIC_APP_NAME。アプリケーション名です。
    • NEW_RELIC_ACCOUNT_ID。お客様のアカウントID
    • NEW_RELIC_TRUSTED_ACCOUNT_KEY これは、お客様のアカウントIDでもあります。アカウントがサブアカウントの場合、これはroot/親アカウントのアカウントIDである必要があります。
  8. オプション:ローカル環境においてAWS以外のサーバーレスモードでエージェントを実行するには、環境変数NEW_RELIC_SERVERLESS_MODE_ENABLEDtrueに設定します。(AWS Lambda環境で実行する場合、エージェントはサーバーレスモードで自動的に実行されます。AWSにおいて実行している場合、この変数を使用しないでください。)
  9. オプション:サーバーレスモードでのロギングを有効にするには、環境変数を次のように設定します:
    • NEW_RELIC_LOG_ENABLEDtrueに設定します。
    • CloudWatchについてNEW_RELIC_LOGstdoutに設定するか、書き込み可能なロケーションに設定します。
    • ログレベルは、デフォルトでinfoに設定されます。その他のログレベルを参照してください。
  10. 少なくとも1回Lambdaを呼び出します。これにより、CloudWatchロググループが作成されます。次のステップを行うには、このグループが必要です。

ラッパーはLambda実行についてのデータを収集し、JSONメッセージを生成し、CloudWatchログに記録します。次に、CloudWatchを設定してそのログをNew Relicに送信します

Python

Python Lambdaをインストゥルメントするには:

  1. Pythonエージェントパッケージをダウンロードし、関数と同じディレクトリに配置します。この場合、pipを使用します:

    pip install -t . newrelic
    

    Homebrewを使用する場合、このエラーが返されます:DistutilsOptionError: homeまたはprefix/exec-prefixのいずれかを(両方ではありません)入力する必要があります。詳細については、Homebrew GitHub postをご覧ください。

  2. Lambdaコードで、Pythonエージェントモジュールをインポートし、New Relicデコレーターを使用してハンドラー関数を修飾します。最初に、コードでNew Relicパッケージをインポートする必要があります。 次の例を見てみましょう。

    import newrelic.agent
    newrelic.agent.initialize()
    
    @newrelic.agent.lambda_handler()
    def handler(event, context):
    ...
    
  3. オプション:record_custom_event APIを使用して、Lambdaにカスタムイベントを追加することもできます。次の例を見てみましょう。

    @newrelic.agent.lambda_handler()
    def handler(event, context):
        newrelic.agent.record_custom_event('CustomEvent', {'foo': 'bar'})
    …
    
  4. このガイドラインを使用して、lambda_function.pynewrelic/フォルダを一緒に圧縮します:

    • newrelic/フォルダに入っていないNew Relicファイルは、含める必要はありません。

    • Lambda関数ファイル名がたとえばlambda_function.pyの場合、zipファイルの名前をlambda_function.zipとしてください。tarballは使用しないでください。

    • Lambdaと関連モジュールはすべて、zipファイルのルートディレクトリに入っている必要があります。つまり、ファイルを含むファイルを圧縮するとうまくいきません。

  5. 圧縮したファイルを、AWS Lambdaアカウントにアップロードします。
  6. AWSコンソールで、次の環境変数を設定します:

    • NEW_RELIC_SERVERLESS_MODE_ENABLEDtrueに設定します。
  7. 次の環境変数はLambdaモニターの機能には不要ですが、Lambda機能をディストリビューティッド(分散)トレーシングに含める場合は必要です。ディストリビューティッド(分散)トレーシングを有効にするには、AWSコンソールで次の環境変数を設定します。
    • NEW_RELIC_DISTRIBUTED_TRACING_ENABLED。trueに設定します。
    • NEW_RELIC_ACCOUNT_ID。お客様のアカウントID
    • NEW_RELIC_TRUSTED_ACCOUNT_KEY これは、お客様のアカウントIDでもあります。アカウントがサブアカウントの場合、これはroot/親アカウントのアカウントIDである必要があります。
  8. オプション:ロギングを設定するには、AWSコンソールでNEW_RELIC_LOGNEW_RELIC_LOG_LEVEL環境変数を使用します。
  9. 少なくとも1回Lambdaを呼び出します。これにより、CloudWatchロググループが作成されます。次のステップを行うには、このグループが必要です。

New RelicデコレーターはLambda実行についてのデータを収集し、JSONメッセージを生成し、CloudWatchログに記録します。次に、CloudWatchを設定してそのログをNew Relicに送信します

ステップ4。CloudWatchログを設定し、New Relic Lambdaへのストリーミングを行う

このステップでは、Lambda関数のCloudWatch Logsストリームを、ステップ2で設定したnewrelic-log-ingestion Lambdaに関連付けます。

Node.jsおよびPythonの場合: ステップ3でServerless Frameworkのプラグインオプションを使用した場合、このステップは不要です。

このステップは、CLIツールまたは手動の手順を使用して行えます。

CLIツールを使用する

モニターしたい全てのLambda関数に関して、このコマンドを実行します:

newrelic-lambda subscriptions install --function FUNCTION_NAME_#1

または、すべてのサポートされた関数にサブスクリプションフィルターを設定するには、このコマンドを実行します:

newrelic-lambda subscriptions install --function all

このコマンドに関する注意点:

  • 1つのAWSアカウントおよびリージョンにつき必要となるのは、1つの newrelic-log-ingestion Lambdaのみです。これに、好きなだけの関数をサブスクライブできます。
  • リージョン指定の引数を含む引数の詳細に関しては、GitHubドキュメントをご覧ください。
  • CloudWatch検証エラーが送信されます。これは、データのレポートには影響を与えません。New Relicでデータレポーティングを確認できた場合は、このエラーメッセージを無視してください。

Logs を使用していて、(Lambdaログだけでなく)すべてのログデータを当社に送信したい場合は、すべてのログをストリーミングするを参照してください。

手動の手順

CLIツールが実行する手動の手順は以下のとおりです:

手動プロセス:CloudWatchログのNew Relic Lambdaへのストリーミングを行う

ステップ2では、newrelic-log-ingestionLambda関数を設定します。Lambda関数をインストゥルメントした後(ステップ3)、newrelic-lambda subscriptionsコマンドはその関数のCloudWatch Logsストリームをnewrelic-log-ingestion Lambdaに関連付けます。これを手動で行う:

  1. CloudWatchを開いて左側のメニューでログを選択してから、監視している関数のロググループを選択します。
  2. Actionsを選択し、AWS Lambdaにストリームを選択します。
  3. Lambda functionの下で、newrelic-log-ingestion関数を選択します。
  4. Log formatJSONに設定します。
  5. サブスクリプションフィルターパターンを?REPORT ?NR_LAMBDA_MONITORING ?"Task timed out"に設定します。または、LOGGING_ENABLED環境変数を使用している場合、すべてのログをNew Relic Logsにストリームし、このフィールドは空欄のままにします。

この手順に関するメモおよび補足事項を参照してください。

上記のメソッドで選択するnewrelic-log-ingestion Lambda関数が、Lambda関数と同じAWSリージョンにあることを確認します。

次のステップ

これらの手順を完了した後、次の操作を実行できます。

当社のnewrelic-log-ingestion関数は、自動的に更新されません。 最善の結果を得て最新の機能にアクセスするため、当社では時々Lambdaモニタリングを更新することを推奨しています。

オプション:すべてのログをNew Relicにストリーミングする

ログ管理を使用していて、すべてのログをNew Relicに報告する場合は、以下の解説に従ってください。

  1. newrelic-log-ingestion Lambdaに移動し、LOGGING_ENABLED環境変数をtrueに設定します
  2. 既存のフィルターパターンを修正することはできないため、削除した後で再度追加する必要があります:
    1. サブスクリプションフィルターパターン""に設定します。モニターの対象となっている各LambdaのLog groupに移動し、newrelic-log-ingestionサブスクリプションを削除します。
    2. サブスクリプションフィルターを再び追加し、Subscription filter patternフィールドは空欄のままにします。

その他のヘルプ

さらに支援が必要な場合は、これらのサポートと学習リソースを確認してください: