package frameworks

import (

"fmt"

"github.com/cloudfoundry/java-buildpack/src/java/common"

"github.com/cloudfoundry/java-buildpack/src/java/resources"

"os"

"path/filepath"

"strings"

"github.com/cloudfoundry/libbuildpack"

)

// NewRelicFramework implements New Relic APM agent support

type NewRelicFramework struct {

context *common.Context

}

// NewNewRelicFramework creates a new New Relic framework instance

func NewNewRelicFramework(ctx *common.Context) *NewRelicFramework {

return &NewRelicFramework{context: ctx}

}

// Detect checks if New Relic should be included

func (n *NewRelicFramework) Detect() (string, error) {

// Check for New Relic service binding

vcapServices, err := GetVCAPServices()

if err != nil {

n.context.Log.Warning("Failed to parse VCAP_SERVICES: %s", err.Error())

return "", nil

}

// New Relic can be bound as:

// - "newrelic" service (marketplace or label)

// - Services with "newrelic" tag

// - User-provided services with "newrelic" in the name (Docker platform)

if vcapServices.HasService("newrelic") || vcapServices.HasTag("newrelic") || vcapServices.HasServiceByNamePattern("newrelic") {

n.context.Log.Info("New Relic service detected!")

return "New Relic Agent", nil

}

// Also check for NEW_RELIC_LICENSE_KEY environment variable

if n.context.Stager.LinkDirectoryInDepDir(filepath.Join(n.context.Stager.BuildDir(), ".new-relic-credentials"), "new-relic-credentials") == nil {

return "New Relic Agent", nil

}

n.context.Log.Debug("New Relic not detected")

return "", nil

}

// findNewRelicAgent locates the newrelic.jar in the agent directory

func (n *NewRelicFramework) findNewRelicAgent(agentDir string) (string, error) {

return FindFileInDirectory(agentDir, "newrelic.jar", []string{"", "newrelic"})

}

// Supply installs the New Relic agent

func (n *NewRelicFramework) Supply() error {

n.context.Log.BeginStep("Installing New Relic Agent")

// Get New Relic agent dependency from manifest

dep, err := n.context.Manifest.DefaultVersion("newrelic")

if err != nil {

n.context.Log.Warning("Unable to determine New Relic version, using default")

dep = libbuildpack.Dependency{

Name: "newrelic",

Version: "8.14.0", // Fallback version

}

}

// Install New Relic agent JAR

agentDir := filepath.Join(n.context.Stager.DepDir(), "new_relic_agent")

if err := n.context.Installer.InstallDependency(dep, agentDir); err != nil {

return fmt.Errorf("failed to install New Relic agent: %w", err)

}

// Install default newrelic.yml configuration from embedded resources

if err := n.installDefaultConfiguration(agentDir); err != nil {

n.context.Log.Warning("Could not install default New Relic configuration: %s", err.Error())

}

n.context.Log.Info("Installed New Relic Agent version %s", dep.Version)

return nil

}

// installDefaultConfiguration installs the default newrelic.yml from embedded resources

func (n *NewRelicFramework) installDefaultConfiguration(agentDir string) error {

configPath := filepath.Join(agentDir, "newrelic.yml")

// Check if configuration already exists (user-provided or from external config)

if _, err := os.Stat(configPath); err == nil {

n.context.Log.Debug("newrelic.yml already exists, skipping default configuration")

return nil

}

// Read embedded newrelic.yml template

embeddedPath := "new_relic_agent/newrelic.yml"

configData, err := resources.GetResource(embeddedPath)

if err != nil {

return fmt.Errorf("failed to read embedded newrelic.yml: %w", err)

}

// Process ERB-style template placeholders

configStr := string(configData)

// Replace <%= generated_for_user %> with buildpack info

configStr = strings.ReplaceAll(configStr, "<%= generated_for_user %>",

"This configuration file was generated by the Cloud Foundry Java Buildpack")

// Replace <%= license_key %> with placeholder (will be set via JAVA_OPTS at runtime)

// The license key will be provided through service bindings in the Finalize phase

configStr = strings.ReplaceAll(configStr, "<%= license_key %>", "YOUR_LICENSE_KEY_HERE")

// Write configuration file

if err := os.WriteFile(configPath, []byte(configStr), 0644); err != nil {

return fmt.Errorf("failed to write newrelic.yml: %w", err)

}

n.context.Log.Info("Installed default New Relic configuration")

n.context.Log.Debug(" - newrelic.yml (license key and app name will be configured via JAVA_OPTS)")

return nil

}

// Finalize performs final New Relic configuration

func (n *NewRelicFramework) Finalize() error {

// Get buildpack index for multi-buildpack support

depsIdx := n.context.Stager.DepsIdx()

// Find the actual New Relic agent jar at staging time

agentDir := filepath.Join(n.context.Stager.DepDir(), "new_relic_agent")

agentJarPath, err := n.findNewRelicAgent(agentDir)

if err != nil {

return fmt.Errorf("failed to locate newrelic.jar: %w", err)

}

// Build runtime path using $DEPS_DIR

relPath, err := filepath.Rel(n.context.Stager.DepDir(), agentJarPath)

if err != nil {

return fmt.Errorf("failed to compute relative path: %w", err)

}

runtimeAgentPath := filepath.Join(fmt.Sprintf("$DEPS_DIR/%s", depsIdx), relPath)

// Add javaagent to JAVA_OPTS

javaOpts := fmt.Sprintf("-javaagent:%s", runtimeAgentPath)

// Get New Relic configuration from service binding

vcapServices, _ := GetVCAPServices()

service := vcapServices.GetService("newrelic")

// If not found by label, try user-provided services (Docker platform)

if service == nil {

service = vcapServices.GetServiceByNamePattern("newrelic")

}

if service != nil {

// Add license key from service credentials

if licenseKey, ok := service.Credentials["licenseKey"].(string); ok && licenseKey != "" {

javaOpts += fmt.Sprintf(" -Dnewrelic.config.license_key=%s", licenseKey)

}

// Add app name from service name

if service.Name != "" {

javaOpts += fmt.Sprintf(" -Dnewrelic.config.app_name='%s'", service.Name)

}

}

// Write to .opts file using priority 35

if err := writeJavaOptsFile(n.context, 35, "new_relic", javaOpts); err != nil {

return fmt.Errorf("failed to write java_opts file: %w", err)

}

n.context.Log.Info("New Relic Agent configured (priority 35)")

return nil

}