newrelic-lambda-cli 0.9.13__py2.py3-none-any.whl → 0.9.15__py2.py3-none-any.whl

newrelic_lambda_cli/api.py

@@ -96,24 +96,23 @@ class NewRelicGQL(object):
         """
         res = self.query(
             """
-            query ($accountId: Int!) {
-              requestContext {
-                apiKey
-              }
-              actor {
-                account(id: $accountId) {
-                  licenseKey
-                  id
-                  name
+                query ($accountId: Int!) {
+                    actor {
+                        apiAccess {
+                            keySearch(query: {types: INGEST, scope: {accountIds: [$accountId]}}) {
+                                keys {
+                                    key
+                                }
+                            }
+                        }
+                    }
                 }
-              }
-            }
             """,
             accountId=self.account_id,
         )
         try:
-            return res["actor"]["account"]["licenseKey"]
-        except KeyError:
+            return res["actor"]["apiAccess"]["keySearch"]["keys"][0]["key"]
+        except (KeyError, IndexError):
             return None
 
     def get_linked_account_by_id(self, id):

newrelic_lambda_cli/apm.py

@@ -0,0 +1,346 @@
+# -*- coding: utf-8 -*-
+
+"""
+
+Example usage:
+
+    >>> from newrelic_lambda_cli.api import NewRelicGQL
+    >>> gql = NewRelicGQL("api key here", "account id here")
+    >>> gql.get_linked_accounts()
+
+"""
+
+from gql import Client, gql
+from gql.transport.requests import RequestsHTTPTransport
+
+import click
+import requests
+import json
+
+from newrelic_lambda_cli.cliutils import failure, success
+
+
+class NRGQL_APM(object):
+    def __init__(self, account_id, api_key, region="us"):
+        try:
+            self.account_id = int(account_id)
+        except ValueError:
+            raise ValueError("Account ID must be an integer")
+
+        self.api_key = api_key
+
+        if region == "us":
+            self.url = "https://api.newrelic.com/graphql"
+        elif region == "eu":
+            self.url = "https://api.eu.newrelic.com/graphql"
+        elif region == "staging":
+            self.url = "https://staging-api.newrelic.com/graphql"
+        else:
+            raise ValueError("Region must be one of 'us' or 'eu'")
+
+        transport = RequestsHTTPTransport(url=self.url, use_json=True)
+        transport.headers = {"api-key": self.api_key}
+
+        try:
+            self.client = Client(transport=transport, fetch_schema_from_transport=True)
+        except Exception:
+            self.client = Client(transport=transport, fetch_schema_from_transport=False)
+
+    def query(self, query, timeout=None, **variable_values):
+        return self.client.execute(
+            gql(query), timeout=timeout, variable_values=variable_values or None
+        )
+
+    def get_entity_guids_from_entity_name(self, entity_name) -> dict[str, str]:
+        entity_dicts = {}
+        res = self.query(
+            f"""
+        query {{
+        actor {{
+            entitySearch(query: "name LIKE '{entity_name}' AND accountId = {self.account_id}") {{
+            results {{
+                entities {{
+                guid
+                name
+                type
+                }}
+            }}
+            }}
+        }}
+        }}
+        """
+        )
+
+        try:
+            data = res
+            entities = data["actor"]["entitySearch"]["results"]["entities"]
+            for entity in entities:
+                if entity["name"] == entity_name:
+                    entity_dicts[entity["type"]] = entity["guid"]
+            return entity_dicts
+        except (KeyError, TypeError) as e:
+            print(f"An error occurred parsing the response: {e}")
+            return None
+        except Exception as e:
+            print(f"An error occurred: {e}")
+            return None
+
+    def get_entity_alert_details(self, entity_guid) -> dict:
+        res = self.query(
+            f"""
+        query {{
+            actor {{
+                entity(guid: "{entity_guid}") {{
+                name
+                guid
+                reporting
+                alertSeverity
+                }}
+                account(id: {self.account_id}) {{
+                alerts {{
+                    nrqlConditionsSearch(searchCriteria: {{queryLike: "{entity_guid}"}}) {{
+                    nrqlConditions {{
+                        id
+                        name
+                        enabled
+                        description
+                        policyId
+                        nrql {{
+                        query
+                        }}
+                        terms {{
+                        operator
+                        priority
+                        threshold
+                        thresholdDuration
+                        thresholdOccurrences
+                        }}
+                    }}
+                    }}
+                }}
+                }}
+            }}
+        }}
+        """
+        )
+
+        print(f"Querying alert details for Lambda entity")
+
+        try:
+            data = res
+            # Check for GraphQL errors in the response
+            if "errors" in data:
+                print("Error in GraphQL response:")
+                for error in data["errors"]:
+                    print(f"- {error.get('message')}")
+                return None
+
+            # Extract the entity data from the response
+            actor_data = data.get("actor", {})
+            entity_data = actor_data.get("entity")
+
+            if not entity_data:
+                print(f"Error: Could not find data for entity with GUID: {entity_guid}")
+                return None
+
+            # Extract alert conditions from the new path and add them to our entity_data dictionary
+            conditions_search_result = (
+                actor_data.get("account", {})
+                .get("alerts", {})
+                .get("nrqlConditionsSearch", {})
+            )
+            entity_data["alertConditions"] = (
+                conditions_search_result.get("nrqlConditions", [])
+                if conditions_search_result
+                else []
+            )
+
+            return entity_data
+
+        except (KeyError, TypeError) as e:
+            print(f"An error occurred parsing the response: {e}")
+            return None
+        except Exception as e:
+            print(f"An error occurred: {e}")
+            return None
+
+    def create_alert_for_new_entity(
+        self, lambda_entity_selected_alerts, lambda_entity_guid, apm_entity_guid
+    ):
+        # Create a list of new NRQL conditions with modified queries
+        new_nrql_conditions = []
+        for alert_condition in lambda_entity_selected_alerts:
+            original_description = alert_condition.get("description") or ""
+            new_description = (
+                f"{original_description} migrated from Lambda entity".strip()
+            )
+            alert_query = alert_condition["nrql"]["query"]
+            alert_query = create_apm_alert_query(
+                alert_query, lambda_entity_guid, apm_entity_guid
+            )
+            new_condition = {
+                "name": alert_condition["name"] + " - apm_migrated",
+                "description": new_description,
+                "enabled": True,
+                "nrql": {"query": alert_query},
+                "terms": alert_condition["terms"],
+            }
+            policy_id = alert_condition.get("policyId")
+            new_nrql_conditions.append((new_condition, policy_id))
+
+        # Process each condition individually
+        results = []
+        for new_condition, policy_id in new_nrql_conditions:
+            # Validate policy_id
+            try:
+                policy_id_int = int(policy_id)
+            except (ValueError, TypeError):
+                print(
+                    f"Error: Invalid policy ID '{policy_id}' for condition '{new_condition['name']}'. Skipping."
+                )
+                continue
+
+            # Format terms as proper GraphQL objects
+            terms_list = []
+            for term in new_condition["terms"]:
+                term_str = "{"
+                term_str += f"operator: {term['operator']}, "
+                term_str += f"priority: {term['priority']}, "
+                term_str += f"threshold: {term['threshold']}, "
+                term_str += f"thresholdDuration: {term['thresholdDuration']}, "
+                term_str += f"thresholdOccurrences: {term['thresholdOccurrences']}"
+                term_str += "}"
+                terms_list.append(term_str)
+
+            terms_str = "[" + ", ".join(terms_list) + "]"
+
+            mutation = f"""
+            mutation {{
+                alertsNrqlConditionStaticCreate(
+                    accountId: {self.account_id}, 
+                    condition: {{
+                        name: "{new_condition['name']}"
+                        description: "{new_condition['description']}"
+                        enabled: {str(new_condition['enabled']).lower()}
+                        nrql: {{
+                            query: "{new_condition['nrql']['query']}"
+                        }}
+                        terms: {terms_str}
+                    }}, 
+                    policyId: "{policy_id_int}"
+                ) {{
+                    id
+                    name
+                    description
+                    nrql {{
+                        query
+                    }}
+                    terms {{
+                        operator
+                        priority
+                        threshold
+                        thresholdDuration
+                        thresholdOccurrences
+                    }}
+                }}
+            }}
+            """
+
+            try:
+                res = self.query(mutation)
+                # Check for GraphQL errors in the response
+                if "errors" in res:
+                    print("Error in GraphQL response:")
+                    for error in res["errors"]:
+                        print(f"- {error.get('message')}")
+                    continue
+
+                result = res["alertsNrqlConditionStaticCreate"]
+                results.append(result)
+                success(f"Successfully migrated to alert: {result['name']}")
+
+            except (KeyError, TypeError) as e:
+                print(f"An error occurred parsing the response: {e}")
+                continue
+            except Exception as e:
+                print(f"An error occurred: {e}")
+                continue
+
+        return results
+
+
+lambda_entity_alert_metric = {
+    "cwBilledDuration": "apm.lambda.transaction.billed_duration",
+    "cwDuration": "apm.lambda.transaction.duration",
+    "cwInitDuration": "apm.lambda.transaction.init_duration",
+    "cwMaxMemoryUsed": "apm.lambda.transaction.max_memory_used",
+    "cwMemorySize": "apm.lambda.transaction.memory_size",
+    "cloudWatchBilledDuration": "apm.lambda.transaction.billed_duration",
+    "cloudWatchDuration": "apm.lambda.transaction.duration",
+    "cloudWatchInitDuration": "apm.lambda.transaction.init_duration",
+}
+
+
+def check_apm_migrated_alerts(lambda_entity_data, apm_entity_data):
+    """
+    Check which Lambda alerts have not been migrated to APM yet.
+    Returns a list of Lambda alert conditions that don't have corresponding APM migrated versions.
+    """
+    if not lambda_entity_data or "alertConditions" not in lambda_entity_data:
+        print("No alert conditions found for Lambda entity.")
+        return []
+
+    if not apm_entity_data or "alertConditions" not in apm_entity_data:
+        print("No alert conditions found for APM entity.")
+        return []
+
+    alerts_not_migrated = []
+    lambda_alert_conditions = lambda_entity_data["alertConditions"]
+    apm_alert_conditions = apm_entity_data["alertConditions"]
+    apm_alerts_name = [condition["name"] for condition in apm_alert_conditions]
+
+    for lambda_condition in lambda_alert_conditions:
+        migrated_lambda_alert_name = lambda_condition["name"] + " - apm_migrated"
+        if migrated_lambda_alert_name not in apm_alerts_name:
+            alerts_not_migrated.append(lambda_condition)
+        else:
+            print(f"Alert already migrated, skipping: {lambda_condition['name']}")
+
+    return alerts_not_migrated
+
+
+def select_lambda_entity_impacted_alerts(entity_data, apm_entity_data=None):
+    if not entity_data or "alertConditions" not in entity_data:
+        print("No alert conditions found.")
+        return []
+
+    selected_alerts = []
+    alert_conditions = entity_data["alertConditions"]
+    for condition in alert_conditions:
+        alert_query = condition["nrql"]["query"]
+        has_lambda_invocation = "AwsLambdaInvocation" in alert_query
+        has_cloudwatch_metrics = any(
+            metric in alert_query for metric in lambda_entity_alert_metric.keys()
+        )
+        if has_lambda_invocation and has_cloudwatch_metrics:
+            print(f"Selected alert for migration: {condition['name']}")
+            selected_alerts.append(condition)
+    if apm_entity_data:
+        selected_alerts = check_apm_migrated_alerts(
+            {"alertConditions": selected_alerts}, apm_entity_data
+        )
+    if len(selected_alerts) == 0:
+        print(
+            "No alerts met the migration criteria (must contain 'AwsLambdaInvocation' or CloudWatch metrics)"
+        )
+    return selected_alerts
+
+
+def create_apm_alert_query(alert_query, lambda_entity_guid, apm_entity_guid):
+    for key, value in lambda_entity_alert_metric.items():
+        if key in alert_query:
+            alert_query = alert_query.replace(key, value)
+            break
+    apm_alert_query = alert_query.replace("AwsLambdaInvocation", "Metric")
+    apm_alert_query = apm_alert_query.replace(lambda_entity_guid, apm_entity_guid)
+    return apm_alert_query

newrelic_lambda_cli/cli/__init__.py

@@ -3,6 +3,7 @@
 import click
 
 from newrelic_lambda_cli.cli import (
+    apm,
     functions,
     integrations,
     layers,
@@ -21,6 +22,7 @@ def cli(ctx, verbose):
 
 
 def register_groups(group):
+    apm.register(group)
     functions.register(group)
     integrations.register(group)
     otel_ingestions.register(group)

newrelic_lambda_cli/cli/apm.py

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+
+import boto3
+import click
+
+from newrelic_lambda_cli import api, apm, otel_ingestions, permissions, integrations
+from newrelic_lambda_cli.types import (
+    AlertsMigrate,
+)
+from newrelic_lambda_cli.cli.decorators import add_options, AWS_OPTIONS, NR_OPTIONS
+from newrelic_lambda_cli.cliutils import done, failure
+
+
+@click.group(name="apm")
+def apm_mode_group():
+    """Manage New Relic APM Mode of AWS Lambda instrumentation"""
+    pass
+
+
+def register(group):
+    group.add_command(apm_mode_group)
+    apm_mode_group.add_command(alerts_migrate)
+
+
+@click.command(name="alerts-migrate")
+@click.option(
+    "--nr-account-id",
+    "-a",
+    envvar="NEW_RELIC_ACCOUNT_ID",
+    help="New Relic Account ID",
+    metavar="<account_id>",
+    required=True,
+    type=click.INT,
+)
+@click.option(
+    "--nr-api-key",
+    "-k",
+    envvar="NEW_RELIC_API_KEY",
+    help="New Relic User API Key",
+    metavar="<key>",
+    required=True,
+)
+@click.option(
+    "--nr-region",
+    default="us",
+    envvar="NEW_RELIC_REGION",
+    help="New Relic Account Region",
+    metavar="<region>",
+    show_default=True,
+    type=click.Choice(["us", "eu", "staging"]),
+)
+@add_options(AWS_OPTIONS)
+@click.option(
+    "function",
+    "--function",
+    "-f",
+    help="AWS Lambda function name or ARN",
+    metavar="<arn>",
+    multiple=False,
+    required=True,
+)
+@click.option(
+    "excludes",
+    "--exclude",
+    "-e",
+    help="Functions to exclude (if using 'all, 'installed', 'not-installed aliases)",
+    metavar="<name>",
+    multiple=True,
+)
+@click.pass_context
+def alerts_migrate(ctx, **kwargs):
+    """Migrate New Relic AWS Lambda Alerts to APM mode"""
+    input = AlertsMigrate(session=None, verbose=ctx.obj["VERBOSE"], **kwargs)
+    input = input._replace(
+        session=boto3.Session(
+            profile_name=input.aws_profile, region_name=input.aws_region
+        )
+    )
+
+    # Validate required parameters
+    if not input.nr_api_key:
+        failure(
+            "New Relic API key is required. Provide it via --nr-api-key or NEW_RELIC_API_KEY environment variable.",
+            exit=True,
+        )
+
+    print("Started migration of alerts")
+    if ctx.obj["VERBOSE"]:
+        print("Will migrate alerts for {}".format(input.function))
+        print(f"Using account ID: {input.nr_account_id}")
+        print(f"Using region: {input.nr_region}")
+
+    # setup client
+    client = apm.NRGQL_APM(
+        account_id=input.nr_account_id,
+        api_key=input.nr_api_key,
+        region=input.nr_region,
+    )
+
+    print(f"Getting entity GUID for function: {input.function}")
+    result = client.get_entity_guids_from_entity_name(input.function)
+    lambda_entity_guid = ""
+    apm_entity_guid = ""
+    for entity_type, entity_guid in result.items():
+        if entity_type == "AWSLAMBDAFUNCTION":
+            lambda_entity_guid = entity_guid
+        if entity_type == "APPLICATION":
+            apm_entity_guid = entity_guid
+    lambda_entity_data = client.get_entity_alert_details(lambda_entity_guid)
+    apm_entity_data = client.get_entity_alert_details(apm_entity_guid)
+    lambda_entity_selected_alerts = apm.select_lambda_entity_impacted_alerts(
+        lambda_entity_data, apm_entity_data
+    )
+    if lambda_entity_selected_alerts:
+        client.create_alert_for_new_entity(
+            lambda_entity_selected_alerts, lambda_entity_guid, apm_entity_guid
+        )
+    else:
+        print(
+            "No alerts need to be migrated - all eligible alerts have already been migrated."
+        )

newrelic_lambda_cli/cli/layers.py

@@ -133,6 +133,12 @@ def register(group):
     is_flag=True,
     help="Enable sending Lambda function logs via the New Relic Lambda Extension",
 )
+@click.option(
+    "--slim",
+    is_flag=True,
+    default=False,
+    help="New Relic slim Layer without opentelemetry for Node.js",
+)
 @click.option(
     "--disable-function-logs",
     is_flag=True,

newrelic_lambda_cli/layers.py

@@ -48,7 +48,12 @@ def index(region, runtime, architecture):
 
 
 def layer_selection(
-    available_layers, runtime, architecture, upgrade=False, existing_layer_arn=None
+    available_layers,
+    runtime,
+    architecture,
+    upgrade=False,
+    existing_layer_arn=None,
+    slim=False,
 ):
     if upgrade and existing_layer_arn:
         base_arn = existing_layer_arn.rsplit(":", 1)[0]
@@ -65,7 +70,11 @@ def layer_selection(
     layer_options = [
         layer["LatestMatchingVersion"]["LayerVersionArn"] for layer in available_layers
     ]
-
+    if slim:
+        for arn in layer_options:
+            if "-slim:" in arn:
+                success("Layer %s selected (slim)" % arn)
+                return arn
     if sys.stdout.isatty():
         output = "\n".join(
             [
@@ -86,11 +95,14 @@ def layer_selection(
             except IndexError:
                 failure("Invalid layer selection")
     else:
-        raise click.UsageError(
+        click.echo(
             "Discovered multiple layers for runtime %s (%s):\n%s\n"
-            "Pass --layer-arn to specify a layer ARN"
+            "To add a particular Layer ARN use --layer-arn"
             % (runtime, architecture, "\n".join(layer_options))
         )
+        selected = layer_options[0]
+        success("Layer %s selected (auto)" % selected)
+        return selected
 
 
 def _add_new_relic(input, config, nr_license_key):
@@ -167,6 +179,7 @@ def _add_new_relic(input, config, nr_license_key):
             architecture,
             upgrade=input.upgrade,
             existing_layer_arn=existing_layer_arn,
+            slim=input.slim,
         )
 
     update_kwargs = {

newrelic_lambda_cli/types.py

@@ -117,6 +117,7 @@ LAYER_INSTALL_KEYS = [
     "disable_extension_logs",
     "java_handler_method",
     "esm",
+    "slim",
 ]
 
 LAYER_UNINSTALL_KEYS = [
@@ -141,6 +142,19 @@ SUBSCRIPTION_INSTALL_KEYS = [
     "otel",
 ]
 
+ALERTS_MIGRATE_KEYS = [
+    "session",
+    "aws_profile",
+    "aws_region",
+    "aws_permissions_check",
+    "nr_account_id",
+    "nr_api_key",
+    "nr_region",
+    "function",
+    "excludes",
+    "verbose",
+]
+
 SUBSCRIPTION_UNINSTALL_KEYS = [
     "session",
     "aws_profile",
@@ -166,5 +180,7 @@ OtelIngestionUpdate = namedtuple("OtelIngestionUpdate", OTEL_INGESTION_UPDATE_KE
 LayerInstall = namedtuple("LayerInstall", LAYER_INSTALL_KEYS)
 LayerUninstall = namedtuple("LayerUninstall", LAYER_UNINSTALL_KEYS)
 
+AlertsMigrate = namedtuple("AlertsMigrate", ALERTS_MIGRATE_KEYS)
+
 SubscriptionInstall = namedtuple("SubscriptionInstall", SUBSCRIPTION_INSTALL_KEYS)
 SubscriptionUninstall = namedtuple("SubscriptionUninstall", SUBSCRIPTION_UNINSTALL_KEYS)

{newrelic_lambda_cli-0.9.13.dist-info → newrelic_lambda_cli-0.9.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: newrelic-lambda-cli
-Version: 0.9.13
+Version: 0.9.15
 Summary: A CLI to install the New Relic AWS Lambda integration and layers.
 Home-page: https://github.com/newrelic/newrelic-lambda-cli
 Author: New Relic
@@ -64,11 +64,11 @@ A CLI to install the New Relic AWS Lambda integration and layers.
 
 | Runtime     | Versions               |
 |-------------|------------------------|
-| Python      | `python3.7`, `python3.8`, `python3.9`, `python3.10`, `python3.11`, `python3.12`, `python3.13` |
+| Python      | `python3.8`, `python3.9`, `python3.10`, `python3.11`, `python3.12`, `python3.13` |
 | Node.js     | `nodejs16.x`, `nodejs18.x`, `nodejs20.x`, `nodejs22.x` |
-| .NET   | `dotnet3.1`, `dotnet6`, `dotnet8`              |
+| .NET   |  `dotnet6`, `dotnet8`              |
 | Java        | `java8.al2`, `java11`, `java17`, `java21`      |
-| Provided    | `provided`, `provided.al2`, `provided.al2023`         |
+| Provided    | `provided.al2`, `provided.al2023`         |
 | Ruby        | `ruby3.2`, `ruby3.3`, `ruby3.4`          |
 
 **Note:** Automatic handler wrapping is only supported for Node.js, Python, Java, and Ruby. For other runtimes,
@@ -78,6 +78,7 @@ manual function wrapping is required using the runtime specific New Relic agent.
 
 * Python >= 3.7 <= 3.13
 * Retrieve your [New relic Account ID](https://docs.newrelic.com/docs/accounts/install-new-relic/account-setup/account-id) and [User API Key](https://docs.newrelic.com/docs/apis/get-started/intro-apis/types-new-relic-api-keys#user-api-key)
+* Retrieve your [New Relic Ingest License Key](https://docs.newrelic.com/docs/apis/intro-apis/new-relic-api-keys/#personal-api-key)
 
 ## Recommendations
 
@@ -199,6 +200,7 @@ newrelic-lambda layers install \
 | `--function` or `-f` | Yes | The AWS Lambda function name or ARN in which to add a layer. Can provide multiple `--function` arguments. Will also accept `all`, `installed` and `not-installed` similar to `newrelic-lambda functions list`. |
 | `--nr-account-id` or `-a` | Yes | The [New Relic Account ID](https://docs.newrelic.com/docs/accounts/install-new-relic/account-setup/account-id) this function should use. Can also use the `NEW_RELIC_ACCOUNT_ID` environment variable. |
 | `--exclude` or `-e` | No | A function name to exclude while installing layers. Can provide multiple `--exclude` arguments. Only checked when `all`, `installed` and `not-installed` are used. See `newrelic-lambda functions list` for function names. |
+| `--slim` | No | The flag `--slim` adds the Node.js layer without OpenTelemetry dependencies, resulting in a lighter size. |
 | `--layer-arn` or `-l` | No | Specify a specific layer version ARN to use. This is auto detected by default. |
 | `--upgrade` or `-u` | No | Permit upgrade to the latest layer version for this region and runtime. |
 | `--disable-extension` | No | Disable the [New Relic Lambda Extension](https://github.com/newrelic/newrelic-lambda-extension). |
@@ -209,6 +211,7 @@ newrelic-lambda layers install \
 | `--aws-profile` or `-p` | No | The AWS profile to use for this command. Can also use `AWS_PROFILE`. Will also check `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` environment variables if not using AWS CLI. |
 | `--aws-region` or `-r` | No | The AWS region this function is located. Can use `AWS_DEFAULT_REGION` environment variable. Defaults to AWS session region. |
 | `--nr-api-key` or `-k` | No | Your [New Relic User API Key](https://docs.newrelic.com/docs/apis/get-started/intro-apis/types-new-relic-api-keys#user-api-key). Can also use the `NEW_RELIC_API_KEY` environment variable. Only used if `--enable-extension` is set and there is no New Relic license key in AWS Secrets Manager. |
+| `--nr-ingest-key`| No | Your [New Relic Ingest License Key](https://docs.newrelic.com/docs/apis/intro-apis/new-relic-api-keys/#personal-api-key). Can be used without `--enable-extension` configured or license key in AWS Secrets Manager. |
 | `--nr-region` | No | The New Relic region to use for the integration. Can use the `NEW_RELIC_REGION` environment variable. Can be either `eu` or `us`. Defaults to `us`. Only used if `--enable-extension` is set and there is no New Relic license key in AWS Secrets Manager. |
 | `--nr-env-delimite` | No | Set `NR_ENV_DELIMITER` environment variable for your Lambda Function |
 | `--nr-tags` | No | Set `NR_TAGS` environment variable for your Lambda Function |
@@ -281,6 +284,17 @@ newrelic-lambda subscriptions uninstall --function <name or arn>
 | `--aws-profile` or `-p` | No | The AWS profile to use for this command. Can also use `AWS_PROFILE`. Will also check `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` environment variables if not using AWS CLI. |
 | `--aws-region` or `-r` | No | The AWS region this function is located. Can use `AWS_DEFAULT_REGION` environment variable. Defaults to AWS session region. |
 
+### NewRelic APM + Serverless Convergence
+
+#### Migrate Alerts from Lambda to APM 
+
+```bash
+newrelic-lambda apm alerts-migrate \
+    --nr-account-id <account id> \
+    --nr-api-key <api key>
+    --function <Lambda-function-name>
+```
+
 ### NewRelic Otel Ingestions Install
 
 #### Install Otel Log Ingestion

{newrelic_lambda_cli-0.9.13.dist-info → newrelic_lambda_cli-0.9.15.dist-info}/RECORD

@@ -1,27 +1,29 @@
 newrelic_lambda_cli/__init__.py,sha256=u4cy7hwbrNjK3xtldGQD_51aoNgSqGQ3IzFYsuvaIM4,149
-newrelic_lambda_cli/api.py,sha256=-lRsWBNO0YWV2yHp-zUbS2vs4AYJCn9yJngOrKAvmuo,15133
+newrelic_lambda_cli/api.py,sha256=eBGq-IV73urdqhAA2xsIdf772q0npMiuRCCiCJgS10Q,15287
+newrelic_lambda_cli/apm.py,sha256=ZGEdmRW8jlJOl17TnTO716dwxpDSvEb5_28K6XadPDA,12475
 newrelic_lambda_cli/cliutils.py,sha256=XDtvTlgbf2uVg01yCJrfJmmgxbF0nIL9x58ETyvefk8,685
 newrelic_lambda_cli/functions.py,sha256=p57ZUw424BaSUA_Gw8DrYsJOYKROEHEaXgARadqwcP0,2800
 newrelic_lambda_cli/integrations.py,sha256=r0gxfEqVHTGu3xbr4dOCDwm0-Yhoz3KntfeQRWvoWrQ,31266
-newrelic_lambda_cli/layers.py,sha256=pyTbSCwJ2A3KP6YZiN-bkzt210UEj3j6dVnIFgijxWo,20339
+newrelic_lambda_cli/layers.py,sha256=BL7XPMw8zal0UL5nrgDJMknfnhwSkp_LKVkBThWx_do,20673
 newrelic_lambda_cli/otel_ingestions.py,sha256=vi1Mlfc9nRvRWV7STwK7fDXZGozG8ufKohmpHcaWGic,9250
 newrelic_lambda_cli/permissions.py,sha256=H7v5IMpKaJIWC4Dff2YcTis4BKAAFIJr9IHWUj1LnF4,9093
 newrelic_lambda_cli/subscriptions.py,sha256=-BYkltqiDLdmhUB_Ot4w-5vvrKcQC6aHcTBLl1mlUlI,9564
-newrelic_lambda_cli/types.py,sha256=_nqOh4VU55CEu5EzUvPVtNeofIuOmF3_DIV1RcT6doA,3526
+newrelic_lambda_cli/types.py,sha256=MC22Gw5u97qcpjLrmExST_2uXSH7qceDEmdMziOslh4,3815
 newrelic_lambda_cli/utils.py,sha256=_XU5tFx9SxEzvp_brFFQtspBz_qoUZ2H_HDxhB_Qr1U,5902
-newrelic_lambda_cli/cli/__init__.py,sha256=FciF2RVqQbpMKqEiN8qjO6qmdLB6Yv8LyyyPYcfJNrc,622
+newrelic_lambda_cli/cli/__init__.py,sha256=vY8EdoHeI5r8DY_zELWMb2hCkm_p6oae6JYPweOq1d4,655
+newrelic_lambda_cli/cli/apm.py,sha256=gISzrUQ7a_QqOmReRGaTdpW1INIpAjPauBbqNt1vuNM,3510
 newrelic_lambda_cli/cli/decorators.py,sha256=a3agkVfy8omkUSL4aKblwSX95xtxYOGASULDYcJDPHk,1786
 newrelic_lambda_cli/cli/functions.py,sha256=RSh2Cowe1_oQup8q5YRidp03z-BITo2uzvDh4zvLr4I,2601
 newrelic_lambda_cli/cli/integrations.py,sha256=aQAWcCCU2kBmbF8fLKwKB9bzSY0uipvnojajjTkhqEs,10461
-newrelic_lambda_cli/cli/layers.py,sha256=LM_vMHcfFAjSCtnaH34P0Jn1ixY07s93EzOBsEgRQK0,7584
+newrelic_lambda_cli/cli/layers.py,sha256=iZ6FBvAXeo-WC48E-bgerMx3JAY_AUCI4BL5Raop6sU,7719
 newrelic_lambda_cli/cli/otel_ingestions.py,sha256=4rTm9iYUo2qdMeqxJSrYLCA6ZXHy5bJnjDn9x54pCYc,6096
 newrelic_lambda_cli/cli/subscriptions.py,sha256=bUupv5iv3mUkC8t31nnI3BahoKxDnUJ8Rgq4QHJcFNU,5890
 newrelic_lambda_cli/templates/import-template.yaml,sha256=0r1yeoqpnqtEMggWomALkPG10NiANPWWBqz03rChch8,3771
 newrelic_lambda_cli/templates/license-key-secret.yaml,sha256=ZldQaLXsyF1K2I4X_AsLdH7kRmLkPUYI3talmhqQyHg,1849
 newrelic_lambda_cli/templates/nr-lambda-integration-role.yaml,sha256=s7T73B_k-mAwgzJrD2xn8YGUNgn2E1V7Exifrl81ViU,2874
-newrelic_lambda_cli-0.9.13.dist-info/licenses/LICENSE,sha256=uuxDzQm0yfq_tNZX0tQYzsZUVRIF0jm3dBLZUojSYzI,11345
-newrelic_lambda_cli-0.9.13.dist-info/METADATA,sha256=FgXCoP0n0coh0xQMDFh8h-QsY4ps6ZpjjfwGHDUsWTs,28715
-newrelic_lambda_cli-0.9.13.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
-newrelic_lambda_cli-0.9.13.dist-info/entry_points.txt,sha256=iks2k9Y4WNgIecsDzreIvMV9pGCjwwKTf33LKKvl2A8,65
-newrelic_lambda_cli-0.9.13.dist-info/top_level.txt,sha256=dxX2w58VgSUFiPD8C_lFuY-T2C1kjfeY0xi8iTh0r44,20
-newrelic_lambda_cli-0.9.13.dist-info/RECORD,,
+newrelic_lambda_cli-0.9.15.dist-info/licenses/LICENSE,sha256=uuxDzQm0yfq_tNZX0tQYzsZUVRIF0jm3dBLZUojSYzI,11345
+newrelic_lambda_cli-0.9.15.dist-info/METADATA,sha256=9Vv9rKLxLmmkFA3e_NaJROzu1oJ9lf_fquYcNLMIpXg,29411
+newrelic_lambda_cli-0.9.15.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
+newrelic_lambda_cli-0.9.15.dist-info/entry_points.txt,sha256=iks2k9Y4WNgIecsDzreIvMV9pGCjwwKTf33LKKvl2A8,65
+newrelic_lambda_cli-0.9.15.dist-info/top_level.txt,sha256=dxX2w58VgSUFiPD8C_lFuY-T2C1kjfeY0xi8iTh0r44,20
+newrelic_lambda_cli-0.9.15.dist-info/RECORD,,