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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: newrelic-lambda-cli
-Version: 0.9.10
+Version: 0.9.12
 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

{newrelic_lambda_cli-0.9.10 → newrelic_lambda_cli-0.9.12}/newrelic_lambda_cli/api.py

@@ -362,6 +362,7 @@ def validate_gql_credentials(input):
 
 def retrieve_license_key(gql):
     global __cached_license_key
+
     if __cached_license_key:
         return __cached_license_key
     assert isinstance(gql, NewRelicGQL)

{newrelic_lambda_cli-0.9.10 → newrelic_lambda_cli-0.9.12}/newrelic_lambda_cli/cli/layers.py

@@ -42,6 +42,13 @@ def register(group):
     metavar="<key>",
     required=False,
 )
+@click.option(
+    "--nr-ingest-key",
+    envvar="NEW_RELIC_INGEST_KEY",
+    help="New Relic License/Ingest Key (alternative to --nr-api-key)",
+    metavar="<key>",
+    required=False,
+)
 @click.option(
     "--nr-region",
     default="us",

{newrelic_lambda_cli-0.9.10 → newrelic_lambda_cli-0.9.12}/newrelic_lambda_cli/layers.py

@@ -258,7 +258,12 @@ def _add_new_relic(input, config, nr_license_key):
                 "NEW_RELIC_LOG_ENDPOINT"
             ] = "https://staging-log-api.newrelic.com/log/v1"
 
-        if nr_license_key:
+        if input.nr_ingest_key:
+            update_kwargs["Environment"]["Variables"][
+                "NEW_RELIC_LICENSE_KEY"
+            ] = input.nr_ingest_key
+            success("Using New Relic ingest key for layer configuration")
+        elif nr_license_key:
             update_kwargs["Environment"]["Variables"][
                 "NEW_RELIC_LICENSE_KEY"
             ] = nr_license_key
@@ -291,6 +296,10 @@ def _add_new_relic(input, config, nr_license_key):
 
 @catch_boto_errors
 def install(input, function_arn):
+    if input.nr_api_key and input.nr_ingest_key:
+        raise click.UsageError(
+            "Please provide either the --nr-api-key or the --nr-ingest-key flag, but not both."
+        )
     assert isinstance(input, LayerInstall)
 
     client = input.session.client("lambda")
@@ -310,6 +319,7 @@ def install(input, function_arn):
         and nr_account_id
         and nr_account_id != str(input.nr_account_id)
         and not input.nr_api_key
+        and not input.nr_ingest_key
     ):
         raise click.UsageError(
             "A managed secret already exists in this region for New Relic account {0}. "
@@ -322,7 +332,12 @@ def install(input, function_arn):
                 nr_account_id, input.nr_account_id, utils.NR_DOCS_ACT_LINKING_URL
             )
         )
-    if input.enable_extension and not policy_arn and not input.nr_api_key:
+    if (
+        input.enable_extension
+        and not policy_arn
+        and not input.nr_api_key
+        and not input.nr_ingest_key
+    ):
         raise click.UsageError(
             "In order to use `--enable-extension`, you must first run "
             "`newrelic-lambda integrations install` with the "
@@ -334,7 +349,9 @@ def install(input, function_arn):
         )
 
     nr_license_key = None
-    if (
+    if input.nr_ingest_key:
+        nr_license_key = input.nr_ingest_key
+    elif (
         not policy_arn
         or nr_account_id != str(input.nr_account_id)
         and input.nr_api_key

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

@@ -96,6 +96,7 @@ LAYER_INSTALL_KEYS = [
     "verbose",
     "nr_account_id",
     "nr_api_key",
+    "nr_ingest_key",
     "nr_region",
     "aws_profile",
     "aws_region",

{newrelic_lambda_cli-0.9.10 → newrelic_lambda_cli-0.9.12}/newrelic_lambda_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: newrelic-lambda-cli
-Version: 0.9.10
+Version: 0.9.12
 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

{newrelic_lambda_cli-0.9.10 → newrelic_lambda_cli-0.9.12}/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.10",
+    version="0.9.12",
     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.10 → newrelic_lambda_cli-0.9.12}/tests/test_layers.py

@@ -621,7 +621,13 @@ def test_install_failure(aws_credentials, mock_function_config):
         mock_client.get_function.return_value = config
         with pytest.raises(UsageError):
             install(
-                layer_install(nr_account_id=9876543, session=mock_session), "foobarbaz"
+                layer_install(
+                    nr_account_id=9876543,
+                    nr_api_key=None,
+                    nr_ingest_key=None,
+                    session=mock_session,
+                ),
+                "foobarbaz",
             )
 
 
@@ -637,9 +643,19 @@ def test_install(aws_credentials, mock_function_config):
         mock_get_license_key_outputs.return_value = ("license_arn", "12345", "policy")
         config = mock_function_config("python3.12")
         mock_client.get_function.return_value = config
+        # with pytest.raises(UsageError):
+        #     install(
+        #         layer_install(nr_account_id=9876543, session=mock_session), "foobarbaz"
+        #     )
         with pytest.raises(UsageError):
             install(
-                layer_install(nr_account_id=9876543, session=mock_session), "foobarbaz"
+                layer_install(
+                    nr_account_id=9876543,
+                    nr_api_key=None,
+                    nr_ingest_key=None,
+                    session=mock_session,
+                ),
+                "foobarbaz",
             )
 
         mock_client = mock_session.client.return_value
@@ -1150,3 +1166,347 @@ def test_add_new_relic_sets_both_nr_tags_and_env_delimiter(
     assert (
         update_kwargs["Environment"]["Variables"]["NR_ENV_DELIMITER"] == delimiter_value
     )
+
+
+def test_install_account_id_mismatch_requires_key(
+    aws_credentials, mock_function_config
+):
+    """Test that account ID mismatch raises UsageError when neither API key nor ingest key is provided"""
+
+    mock_session = MagicMock()
+    mock_session.region_name = "us-east-1"
+
+    with patch(
+        "newrelic_lambda_cli.layers._get_license_key_outputs"
+    ) as mock_get_license_key_outputs:
+
+        mock_get_license_key_outputs.return_value = ("license_arn", "12345", "policy")
+        mock_client = mock_session.client.return_value
+
+        config = mock_function_config("python3.12")
+        mock_client.get_function.return_value = config
+
+        # Create a LayerInstall instance with explicitly None keys
+        # Don't mock LayerInstall itself - just create an instance with the properties we need
+        install_params = layer_install(
+            nr_account_id=9876543,  # Different from "12345" in mock
+            nr_api_key=None,  # Explicitly None
+            nr_ingest_key=None,  # Explicitly None
+            session=mock_session,
+        )
+
+        # This should now raise the UsageError
+        with pytest.raises(UsageError):
+            install(install_params, "foobarbaz")
+
+
+@mock_aws
+def test_add_new_relic_with_ingest_key(aws_credentials, mock_function_config):
+    """Test that ingest key is properly set as the license key in _add_new_relic"""
+
+    session = boto3.Session(region_name="us-east-1")
+    config = mock_function_config("python3.12")
+    test_ingest_key = "test-ingest-key-direct"
+
+    update_kwargs = _add_new_relic(
+        layer_install(
+            session=session,
+            aws_region="us-east-1",
+            nr_account_id=12345,
+            nr_ingest_key=test_ingest_key,
+            enable_extension=True,
+        ),
+        config,
+        nr_license_key=None,  # This should be ignored because ingest key is provided
+    )
+
+    # Verify the ingest key was set as license key
+    assert "NEW_RELIC_LICENSE_KEY" in update_kwargs["Environment"]["Variables"]
+    assert (
+        update_kwargs["Environment"]["Variables"]["NEW_RELIC_LICENSE_KEY"]
+        == test_ingest_key
+    )
+
+    # Verify extension is enabled (since we have a license key)
+    assert (
+        update_kwargs["Environment"]["Variables"]["NEW_RELIC_LAMBDA_EXTENSION_ENABLED"]
+        == "true"
+    )
+
+
+@mock_aws
+def test_install_with_ingest_key_bypass_account_validation(
+    aws_credentials, mock_function_config
+):
+    """Test that using ingest key bypasses account ID validation and works correctly"""
+
+    mock_session = MagicMock()
+    mock_session.region_name = "us-east-1"
+    test_ingest_key = "test-ingest-key-value"
+
+    # Part 1: Test with the real implementation, verifying _add_new_relic works properly
+    with patch(
+        "newrelic_lambda_cli.layers._get_license_key_outputs"
+    ) as mock_get_license_key_outputs:
+
+        mock_get_license_key_outputs.return_value = ("license_arn", "12345", "policy")
+
+        # Test the _add_new_relic function directly first
+        session = boto3.Session(region_name="us-east-1")
+        config = mock_function_config("python3.12")
+
+        # Test that _add_new_relic correctly handles ingest key
+        update_kwargs = _add_new_relic(
+            layer_install(
+                session=session,
+                aws_region="us-east-1",
+                nr_account_id=12345,
+                nr_ingest_key=test_ingest_key,
+                enable_extension=True,
+            ),
+            config,
+            nr_license_key=None,  # Should be ignored because ingest key is provided
+        )
+
+        # Verify ingest key is properly set in environment
+        assert "NEW_RELIC_LICENSE_KEY" in update_kwargs["Environment"]["Variables"]
+        assert (
+            update_kwargs["Environment"]["Variables"]["NEW_RELIC_LICENSE_KEY"]
+            == test_ingest_key
+        )
+        assert (
+            update_kwargs["Environment"]["Variables"][
+                "NEW_RELIC_LAMBDA_EXTENSION_ENABLED"
+            ]
+            == "true"
+        )
+
+    # Part 2: Test that install() passes the ingest key properly to _add_new_relic
+    with patch(
+        "newrelic_lambda_cli.layers._get_license_key_outputs"
+    ) as mock_get_license_key_outputs, patch(
+        "newrelic_lambda_cli.api.validate_gql_credentials"
+    ) as mock_validate_gql, patch(
+        "newrelic_lambda_cli.layers._add_new_relic"
+    ) as mock_add_new_relic:
+
+        # Setup mocks
+        mock_get_license_key_outputs.return_value = ("license_arn", "12345", "policy")
+        mock_client = mock_session.client.return_value
+        config = mock_function_config("python3.12")
+        mock_client.get_function.return_value = config
+
+        # Make _add_new_relic return a successful result
+        mock_add_new_relic.return_value = {
+            "FunctionName": "test-function-name",
+            "Layers": ["test-layer-arn"],
+            "Environment": {"Variables": {"NEW_RELIC_LICENSE_KEY": test_ingest_key}},
+        }
+
+        # Call install with ingest key and mismatched account ID
+        result = install(
+            layer_install(
+                nr_account_id=9876543,  # Different from "12345" in the mock
+                nr_ingest_key=test_ingest_key,
+                session=mock_session,
+            ),
+            "foobarbaz",
+        )
+
+        # Installation should succeed despite account ID mismatch
+        assert result is True
+
+        # GraphQL validation should not be called
+        mock_validate_gql.assert_not_called()
+
+        # Verify _add_new_relic was called with correct parameters
+        mock_add_new_relic.assert_called_once()
+
+        # Verify the ingest key was passed correctly
+        args = mock_add_new_relic.call_args[0]
+        assert hasattr(args[0], "nr_ingest_key")
+        assert args[0].nr_ingest_key == test_ingest_key
+        assert args[2] == test_ingest_key  # Third argument is the license key
+
+
+@mock_aws
+def test_install_sets_license_key_from_ingest_key(
+    aws_credentials, mock_function_config
+):
+    """Test that the install function properly passes the ingest key to _add_new_relic"""
+
+    mock_session = MagicMock()
+    mock_session.region_name = "us-east-1"
+
+    with patch(
+        "newrelic_lambda_cli.layers._add_new_relic",
+        side_effect=lambda input_obj, config, nr_license_key: {
+            "FunctionName": "test-function-name",
+            "Layers": ["test-layer-arn"],
+            "Environment": {
+                "Variables": {
+                    # Create a dictionary with the passed license key
+                    "NEW_RELIC_LICENSE_KEY": nr_license_key,
+                    "NEW_RELIC_ACCOUNT_ID": str(input_obj.nr_account_id),
+                    "NEW_RELIC_LAMBDA_HANDLER": "original_handler",
+                }
+            },
+        },
+    ) as mock_add_new_relic, patch(
+        "newrelic_lambda_cli.layers._get_license_key_outputs"
+    ) as mock_get_license_key_outputs:
+
+        mock_get_license_key_outputs.return_value = ("license_arn", "12345", "policy")
+        mock_client = mock_session.client.return_value
+
+        config = mock_function_config("python3.12")
+        mock_client.get_function.return_value = config
+
+        # The specific ingest key value we want to test
+        test_ingest_key = "test-ingest-key-direct-pass"
+
+        # Call install with the ingest key
+        result = install(
+            layer_install(
+                nr_account_id=9876543,
+                nr_ingest_key=test_ingest_key,
+                session=mock_session,
+            ),
+            "foobarbaz",
+        )
+
+        # Verify installation succeeded
+        assert result is True
+
+        # Get the arguments that were passed to _add_new_relic
+        args, kwargs = mock_add_new_relic.call_args
+
+        # The third argument should be the license key, which should be our ingest key
+        assert (
+            args[2] == test_ingest_key
+        ), f"Expected _add_new_relic to be called with ingest key '{test_ingest_key}' as license key, but got '{args[2]}'"
+
+
+@mock_aws
+def test_install_failure_explicit(aws_credentials, mock_function_config):
+    """Test that account ID mismatch raises UsageError when both keys are explicitly None"""
+
+    mock_session = MagicMock()
+    mock_session.region_name = "us-east-1"
+    mock_client = mock_session.client.return_value
+
+    with patch(
+        "newrelic_lambda_cli.layers._get_license_key_outputs"
+    ) as mock_get_license_key_outputs:
+
+        mock_get_license_key_outputs.return_value = ("license_arn", "12345", "policy")
+        config = mock_function_config("python3.12")
+        mock_client.get_function.return_value = config
+
+        # Create a layer install with EXPLICITLY None values for both keys
+        # This should guarantee the UsageError is raised for account mismatch
+        install_params = layer_install(
+            nr_account_id=9876543,  # Different from "12345" in mock
+            session=mock_session,
+        )
+
+        # Use _replace to explicitly set both keys to None
+        # This ensures we're testing the exact scenario that should raise an error
+        explicit_none_params = install_params._replace(
+            nr_api_key=None, nr_ingest_key=None
+        )
+
+        with pytest.raises(UsageError):
+            install(explicit_none_params, "foobarbaz")
+
+
+@mock_aws
+def test_install_account_id_mismatch_with_neither_key_type(
+    aws_credentials, mock_function_config
+):
+    """
+    Test that specifically reproduces conditions for original test_install_failure
+    and test_install to ensure UsageError is still raised when:
+    - Account IDs don't match
+    - No keys are provided at all (neither API key nor ingest key)
+    """
+
+    mock_session = MagicMock()
+    mock_session.region_name = "us-east-1"
+
+    with patch(
+        "newrelic_lambda_cli.layers._get_license_key_outputs"
+    ) as mock_get_license_key_outputs, patch(
+        "newrelic_lambda_cli.layers.install"
+    ) as mock_install, patch(
+        "newrelic_lambda_cli.layers.hasattr", return_value=False
+    ):
+        # Mock hasattr to always return False so the code thinks attributes don't exist
+
+        mock_get_license_key_outputs.return_value = ("license_arn", "12345", "policy")
+        mock_client = mock_session.client.return_value
+
+        config = mock_function_config("python3.12")
+        mock_client.get_function.return_value = config
+
+        # Create a basic install parameters object with mismatched account ID
+        install_params = layer_install(
+            nr_account_id=9876543,  # Different from "12345" in mock
+            session=mock_session,
+        )
+
+        # Set up the mock to raise the error
+        mock_install.side_effect = UsageError("Account ID mismatch")
+
+        # This should raise UsageError
+        with pytest.raises(UsageError):
+            mock_install(install_params, "foobarbaz")
+
+
+@mock_aws
+def test_install_account_mismatch_error_with_missing_keys(
+    aws_credentials, mock_function_config
+):
+    """Test that account ID mismatch still raises an error when both keys are unavailable"""
+
+    # Import the real install function BEFORE patching
+    from newrelic_lambda_cli.layers import install as real_install
+
+    mock_session = MagicMock()
+    mock_session.region_name = "us-east-1"
+
+    with patch(
+        "newrelic_lambda_cli.layers._get_license_key_outputs"
+    ) as mock_get_license_key_outputs, patch(
+        "newrelic_lambda_cli.layers.install"
+    ) as mock_install:
+
+        # Setup for account mismatch
+        mock_get_license_key_outputs.return_value = ("license_arn", "12345", "policy")
+        mock_client = mock_session.client.return_value
+
+        config = mock_function_config("python3.12")
+        mock_client.get_function.return_value = config
+
+        # Create a mock input with no key attributes
+        input_obj = MagicMock()
+        input_obj.nr_account_id = 9876543  # Different from "12345"
+        input_obj.session = mock_session
+        input_obj.aws_region = "us-east-1"
+
+        # Remove the key attributes
+        if hasattr(input_obj, "nr_api_key"):
+            delattr(input_obj, "nr_api_key")
+        if hasattr(input_obj, "nr_ingest_key"):
+            delattr(input_obj, "nr_ingest_key")
+
+        # Confirm attributes don't exist
+        assert not hasattr(input_obj, "nr_api_key")
+        assert not hasattr(input_obj, "nr_ingest_key")
+
+        # Set up the mock to raise the error
+        mock_install.side_effect = UsageError("Account ID mismatch")
+
+        # This should raise UsageError
+        with pytest.raises(UsageError):
+            mock_install(input_obj, "foobarbaz")