newrelic-lambda-cli 0.9.12__tar.gz → 0.9.14__tar.gz

{newrelic_lambda_cli-0.9.12 → newrelic_lambda_cli-0.9.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: newrelic-lambda-cli
-Version: 0.9.12
+Version: 0.9.14
 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
@@ -281,6 +281,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.12 → newrelic_lambda_cli-0.9.14}/README.md

@@ -255,6 +255,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.14/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-0.9.12 → newrelic_lambda_cli-0.9.14}/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-0.9.14/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-0.9.12 → newrelic_lambda_cli-0.9.14}/newrelic_lambda_cli/layers.py

@@ -47,7 +47,18 @@ def index(region, runtime, architecture):
     ]
 
 
-def layer_selection(available_layers, runtime, architecture):
+def layer_selection(
+    available_layers, runtime, architecture, upgrade=False, existing_layer_arn=None
+):
+    if upgrade and existing_layer_arn:
+        base_arn = existing_layer_arn.rsplit(":", 1)[0]
+
+        for i, layer in enumerate(available_layers):
+            candidate_arn = layer["LatestMatchingVersion"]["LayerVersionArn"]
+            candidate_base_arn = candidate_arn.rsplit(":", 1)[0]
+            if candidate_base_arn == base_arn:
+                return candidate_arn
+
     if len(available_layers) == 1:
         return available_layers[0]["LatestMatchingVersion"]["LayerVersionArn"]
 
@@ -147,8 +158,16 @@ def _add_new_relic(input, config, nr_license_key):
                 % (config["Configuration"]["FunctionArn"], runtime, architecture)
             )
             return False
-
-        new_relic_layer = layer_selection(available_layers, runtime, architecture)
+        existing_layer_arn = (
+            existing_newrelic_layer[0] if existing_newrelic_layer else None
+        )
+        new_relic_layer = layer_selection(
+            available_layers,
+            runtime,
+            architecture,
+            upgrade=input.upgrade,
+            existing_layer_arn=existing_layer_arn,
+        )
 
     update_kwargs = {
         "FunctionName": config["Configuration"]["FunctionArn"],

{newrelic_lambda_cli-0.9.12 → newrelic_lambda_cli-0.9.14}/newrelic_lambda_cli/types.py

@@ -141,6 +141,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 +179,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.12 → newrelic_lambda_cli-0.9.14}/newrelic_lambda_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: newrelic-lambda-cli
-Version: 0.9.12
+Version: 0.9.14
 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
@@ -281,6 +281,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.12 → newrelic_lambda_cli-0.9.14}/newrelic_lambda_cli.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ setup.cfg
 setup.py
 newrelic_lambda_cli/__init__.py
 newrelic_lambda_cli/api.py
+newrelic_lambda_cli/apm.py
 newrelic_lambda_cli/cliutils.py
 newrelic_lambda_cli/functions.py
 newrelic_lambda_cli/integrations.py
@@ -26,6 +27,7 @@ newrelic_lambda_cli.egg-info/not-zip-safe
 newrelic_lambda_cli.egg-info/requires.txt
 newrelic_lambda_cli.egg-info/top_level.txt
 newrelic_lambda_cli/cli/__init__.py
+newrelic_lambda_cli/cli/apm.py
 newrelic_lambda_cli/cli/decorators.py
 newrelic_lambda_cli/cli/functions.py
 newrelic_lambda_cli/cli/integrations.py

{newrelic_lambda_cli-0.9.12 → newrelic_lambda_cli-0.9.14}/setup.py

@@ -6,7 +6,7 @@ README = open(os.path.join(os.path.dirname(__file__), "README.md"), "r").read()
 
 setup(
     name="newrelic-lambda-cli",
-    version="0.9.12",
+    version="0.9.14",
     python_requires=">=3.3",
     description="A CLI to install the New Relic AWS Lambda integration and layers.",
     long_description=README,

{newrelic_lambda_cli-0.9.12 → newrelic_lambda_cli-0.9.14}/tests/test_layers.py

@@ -143,7 +143,11 @@ def test_add_new_relic(aws_credentials, mock_function_config):
             )
 
             layer_selection_mock.assert_called_with(
-                mock_index.return_value, "java11", "x86_64"
+                mock_index.return_value,
+                "java11",
+                "x86_64",
+                upgrade=None,
+                existing_layer_arn=None,
             )
             assert "original_handler" in config["Configuration"]["Handler"]
 
@@ -417,7 +421,6 @@ def test_add_new_relic_nodejs(aws_credentials, mock_function_config):
 
     runtime = "nodejs20.x"
 
-    # --- Scenario 1: Standard Node.js Handler (ESM disabled) ---
     print(f"\nTesting Node.js ({runtime}) Standard Handler...")
     original_std_handler = "original_handler"
     config_std = mock_function_config(runtime)
@@ -430,11 +433,16 @@ def test_add_new_relic_nodejs(aws_credentials, mock_function_config):
         enable_extension_function_logs=True,
     )
 
-    update_kwargs_std = _add_new_relic(
-        install_opts_std,
-        config_std,
-        nr_license_key=nr_license_key,
-    )
+    with patch("sys.stdout.isatty") as mock_isatty, patch(
+        "newrelic_lambda_cli.layers.click.prompt"
+    ) as mock_prompt:
+        mock_isatty.return_value = True
+        mock_prompt.return_value = 0
+        update_kwargs_std = _add_new_relic(
+            install_opts_std,
+            config_std,
+            nr_license_key=nr_license_key,
+        )
 
     assert update_kwargs_std is not False, "Expected update_kwargs, not False"
     assert (
@@ -479,11 +487,16 @@ def test_add_new_relic_nodejs(aws_credentials, mock_function_config):
         esm=True,
     )
 
-    update_kwargs_esm = _add_new_relic(
-        install_opts_esm,
-        config_esm,
-        nr_license_key=nr_license_key,
-    )
+    with patch("sys.stdout.isatty") as mock_isatty, patch(
+        "newrelic_lambda_cli.layers.click.prompt"
+    ) as mock_prompt:
+        mock_isatty.return_value = True
+        mock_prompt.return_value = 0
+        update_kwargs_esm = _add_new_relic(
+            install_opts_esm,
+            config_esm,
+            nr_license_key=nr_license_key,
+        )
 
     assert update_kwargs_esm is not False, "Expected update_kwargs, not False"
     assert (