feat: Improve serverless mode detection (#2661)

tippmar-nr · web-flow · commit 5f5dda860a78 · 2024-08-01T14:44:02.000-05:00
diff --git a/src/Agent/NewRelic/Home/Home.csproj b/src/Agent/NewRelic/Home/Home.csproj
@@ -13,7 +13,7 @@
   </Target>
 
   <ItemGroup>
-    <PackageReference Include="NewRelic.Agent.Internal.Profiler" Version="10.25.1.10"/>
+    <PackageReference Include="NewRelic.Agent.Internal.Profiler" Version="10.27.0.15"/>
   </ItemGroup>
 
 </Project>
diff --git a/src/Agent/NewRelic/Profiler/Configuration/InstrumentationConfiguration.h b/src/Agent/NewRelic/Profiler/Configuration/InstrumentationConfiguration.h
@@ -126,30 +126,36 @@ namespace NewRelic { namespace Profiler { namespace Configuration
                 return;
             }
 
-            auto lambdaInstPoint = _systemCalls->TryGetEnvironmentVariable(_X("_HANDLER"));
+            // give precedence to the NEW_RELIC_LAMBDA_HANDLER environment variable
+            auto lambdaInstPoint = _systemCalls->TryGetEnvironmentVariable(_X("NEW_RELIC_LAMBDA_HANDLER"));
             if (lambdaInstPoint != nullptr)
             {
-                AddInstrumentationPointToCollectionFromEnvironment(*lambdaInstPoint);
-                _foundServerlessInstrumentationPoint = true;
-                return;
+                LogDebug("Found NEW_RELIC_LAMBDA_HANDLER environment variable: ", *lambdaInstPoint);
+                if (TryAddInstrumentationPointToCollectionFromEnvironment(*lambdaInstPoint))
+                {
+                    _foundServerlessInstrumentationPoint = true;
+                    return;
+                }
             }
 
-            lambdaInstPoint = _systemCalls->TryGetEnvironmentVariable(_X("NEW_RELIC_LAMBDA_HANDLER"));
+            lambdaInstPoint = _systemCalls->TryGetEnvironmentVariable(_X("_HANDLER"));
             if (lambdaInstPoint != nullptr)
             {
-                AddInstrumentationPointToCollectionFromEnvironment(*lambdaInstPoint);
-                _foundServerlessInstrumentationPoint = true;
+                LogDebug("Found _HANDLER environment variable: ", *lambdaInstPoint);
+                if (TryAddInstrumentationPointToCollectionFromEnvironment(*lambdaInstPoint))
+                    _foundServerlessInstrumentationPoint = true;
             }
         }
 
-        void AddInstrumentationPointToCollectionFromEnvironment(xstring_t text)
+        bool TryAddInstrumentationPointToCollectionFromEnvironment(xstring_t text)
         {
             auto segments = Strings::Split(text, _X("::"));
             if (segments.size() != 3)
             {
                 LogWarn(text, L" is not a valid method descriptor. It must be in the format 'assembly::class::method'");
-                return;
+                return false;
             }
+
             LogInfo(L"Serverless mode detected. Assembly: ", segments[0], L" Class: ", segments[1], L" Method: ", segments[2]);
 
             InstrumentationPointPtr instrumentationPoint(new InstrumentationPoint());
@@ -167,6 +173,8 @@ namespace NewRelic { namespace Profiler { namespace Configuration
 
             (*_instrumentationPointsMap)[instrumentationPoint->GetMatchKey()].insert(instrumentationPoint);
             _instrumentationPointsSet->insert(instrumentationPoint);
+
+            return true;
         }
 
     private:
diff --git a/src/Agent/NewRelic/Profiler/ConfigurationTest/InstrumentationConfigurationTest.cpp b/src/Agent/NewRelic/Profiler/ConfigurationTest/InstrumentationConfigurationTest.cpp
@@ -956,7 +956,7 @@ namespace NewRelic { namespace Profiler { namespace Configuration { namespace Te
             xmlSet->emplace(L"filename", L"<?xml version=\"1.0\" encoding=\"utf-8\"?>");
 
             InstrumentationConfiguration instrumentation(xmlSet, nullptr);
-            instrumentation.AddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly::MyNamespace.MyClass::MyMethod"));
+            instrumentation.TryAddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly::MyNamespace.MyClass::MyMethod"));
 
             auto instrumentationPoint = instrumentation.TryGetInstrumentationPoint(std::make_shared<MethodRewriter::Test::MockFunction>());
             Assert::IsFalse(instrumentationPoint == nullptr);
@@ -968,21 +968,21 @@ namespace NewRelic { namespace Profiler { namespace Configuration { namespace Te
             xmlSet->emplace(L"filename", L"<?xml version=\"1.0\" encoding=\"utf-8\"?>");
 
             InstrumentationConfiguration instrumentation(xmlSet, nullptr);
-            instrumentation.AddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly::MyNamespace.MyClass::"));
-            instrumentation.AddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly::MyNamespace.MyClass::WrongMethod"));
-            instrumentation.AddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly::MyMethod"));
-            instrumentation.AddInstrumentationPointToCollectionFromEnvironment(_X("MyNamespace.MyClass:MyMethod"));
-            instrumentation.AddInstrumentationPointToCollectionFromEnvironment(_X("MyMethod"));
-            instrumentation.AddInstrumentationPointToCollectionFromEnvironment(_X(":::MyMethod"));
-            instrumentation.AddInstrumentationPointToCollectionFromEnvironment(_X("::::::MyMethod"));
-            instrumentation.AddInstrumentationPointToCollectionFromEnvironment(_X(":::MyMethod::"));
-            instrumentation.AddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly:MyNamespace.MyClass:MyMethod"));
-            instrumentation.AddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly/MyNamespace.MyClass/MyMethod"));
-            instrumentation.AddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly_MyNamespace.MyClass_MyMethod"));
-            instrumentation.AddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly MyNamespace.MyClass MyMethod"));
-            instrumentation.AddInstrumentationPointToCollectionFromEnvironment(_X(" MyAssembly::MyNamespace.MyClass:MyMethod"));
-            instrumentation.AddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly::MyNamespace.MyClass::MyMethod"));
-            instrumentation.AddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly::MyNamespace .MyClass:: MyMethod"));
+            instrumentation.TryAddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly::MyNamespace.MyClass::"));
+            instrumentation.TryAddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly::MyNamespace.MyClass::WrongMethod"));
+            instrumentation.TryAddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly::MyMethod"));
+            instrumentation.TryAddInstrumentationPointToCollectionFromEnvironment(_X("MyNamespace.MyClass:MyMethod"));
+            instrumentation.TryAddInstrumentationPointToCollectionFromEnvironment(_X("MyMethod"));
+            instrumentation.TryAddInstrumentationPointToCollectionFromEnvironment(_X(":::MyMethod"));
+            instrumentation.TryAddInstrumentationPointToCollectionFromEnvironment(_X("::::::MyMethod"));
+            instrumentation.TryAddInstrumentationPointToCollectionFromEnvironment(_X(":::MyMethod::"));
+            instrumentation.TryAddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly:MyNamespace.MyClass:MyMethod"));
+            instrumentation.TryAddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly/MyNamespace.MyClass/MyMethod"));
+            instrumentation.TryAddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly_MyNamespace.MyClass_MyMethod"));
+            instrumentation.TryAddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly MyNamespace.MyClass MyMethod"));
+            instrumentation.TryAddInstrumentationPointToCollectionFromEnvironment(_X(" MyAssembly::MyNamespace.MyClass:MyMethod"));
+            instrumentation.TryAddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly::MyNamespace.MyClass::MyMethod"));
+            instrumentation.TryAddInstrumentationPointToCollectionFromEnvironment(_X("MyAssembly::MyNamespace .MyClass:: MyMethod"));
 
             auto instrumentationPoint = instrumentation.TryGetInstrumentationPoint(std::make_shared<MethodRewriter::Test::MockFunction>());
             Assert::IsFalse(instrumentationPoint == nullptr);

Original file line number	Diff line number	Diff line change
`@@ -126,30 +126,36 @@ namespace NewRelic { namespace Profiler { namespace Configuration`
`126`	`126`	`return;`
`127`	`127`	`}`
`128`	`128`
`129`		`- auto lambdaInstPoint = _systemCalls->TryGetEnvironmentVariable(_X("_HANDLER"));`
	`129`	`+ // give precedence to the NEW_RELIC_LAMBDA_HANDLER environment variable`
	`130`	`+ auto lambdaInstPoint = _systemCalls->TryGetEnvironmentVariable(_X("NEW_RELIC_LAMBDA_HANDLER"));`
`130`	`131`	`if (lambdaInstPoint != nullptr)`
`131`	`132`	`{`
`132`		`- AddInstrumentationPointToCollectionFromEnvironment(*lambdaInstPoint);`
`133`		`- _foundServerlessInstrumentationPoint = true;`
`134`		`- return;`
	`133`	`+ LogDebug("Found NEW_RELIC_LAMBDA_HANDLER environment variable: ", *lambdaInstPoint);`
	`134`	`+ if (TryAddInstrumentationPointToCollectionFromEnvironment(*lambdaInstPoint))`
	`135`	`+ {`
	`136`	`+ _foundServerlessInstrumentationPoint = true;`
	`137`	`+ return;`
	`138`	`+ }`
`135`	`139`	`}`
`136`	`140`
`137`		`- lambdaInstPoint = _systemCalls->TryGetEnvironmentVariable(_X("NEW_RELIC_LAMBDA_HANDLER"));`
	`141`	`+ lambdaInstPoint = _systemCalls->TryGetEnvironmentVariable(_X("_HANDLER"));`
`138`	`142`	`if (lambdaInstPoint != nullptr)`
`139`	`143`	`{`
`140`		`- AddInstrumentationPointToCollectionFromEnvironment(*lambdaInstPoint);`
`141`		`- _foundServerlessInstrumentationPoint = true;`
	`144`	`+ LogDebug("Found _HANDLER environment variable: ", *lambdaInstPoint);`
	`145`	`+ if (TryAddInstrumentationPointToCollectionFromEnvironment(*lambdaInstPoint))`
	`146`	`+ _foundServerlessInstrumentationPoint = true;`
`142`	`147`	`}`
`143`	`148`	`}`
`144`	`149`
`145`		`- void AddInstrumentationPointToCollectionFromEnvironment(xstring_t text)`
	`150`	`+ bool TryAddInstrumentationPointToCollectionFromEnvironment(xstring_t text)`
`146`	`151`	`{`
`147`	`152`	`auto segments = Strings::Split(text, _X("::"));`
`148`	`153`	`if (segments.size() != 3)`
`149`	`154`	`{`
`150`	`155`	`LogWarn(text, L" is not a valid method descriptor. It must be in the format 'assembly::class::method'");`
`151`		`- return;`
	`156`	`+ return false;`
`152`	`157`	`}`
	`158`	`+`
`153`	`159`	`LogInfo(L"Serverless mode detected. Assembly: ", segments[0], L" Class: ", segments[1], L" Method: ", segments[2]);`
`154`	`160`
`155`	`161`	`InstrumentationPointPtr instrumentationPoint(new InstrumentationPoint());`
`@@ -167,6 +173,8 @@ namespace NewRelic { namespace Profiler { namespace Configuration`
`167`	`173`
`168`	`174`	`(*_instrumentationPointsMap)[instrumentationPoint->GetMatchKey()].insert(instrumentationPoint);`
`169`	`175`	`_instrumentationPointsSet->insert(instrumentationPoint);`
	`176`	`+`
	`177`	`+ return true;`
`170`	`178`	`}`
`171`	`179`
`172`	`180`	`private:`