feat: adding function for checking wrapped into instrumentation (#1572)

Author: obecny

packages/opentelemetry-instrumentation/src/types.ts

@@ -67,3 +67,13 @@ export interface InstrumentationConfig {
    */
   path?: string;
 }
+
+/**
+ * This interface defines the params that are be added to the wrapped function
+ * using the "shimmer.wrap"
+ */
+export interface ShimWrapped {
+  __wrapped: boolean;
+  __unwrap: Function;
+  __original: Function;
+}

packages/opentelemetry-instrumentation/src/utils.ts

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import { ShimWrapped } from './types';
+
 /**
  * function to execute patched function and being able to catch errors
  * @param execute - function to be executed
@@ -39,3 +41,16 @@ export function safeExecuteInTheMiddle<T>(
     return result as T;
   }
 }
+
+/**
+ * Checks if certain function has been already wrapped
+ * @param func
+ */
+export function isWrapped(func: any) {
+  return (
+    typeof func === 'function' &&
+    typeof (func as ShimWrapped).__original === 'function' &&
+    typeof (func as ShimWrapped).__unwrap === 'function' &&
+    (func as ShimWrapped).__wrapped === true
+  );
+}

packages/opentelemetry-instrumentation/test/common/utils.test.ts

@@ -0,0 +1,44 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as assert from 'assert';
+import { isWrapped } from '../../src';
+
+describe('isWrapped', () => {
+  describe('when function is wrapped', () => {
+    it('should return true', () => {
+      const obj: any = {
+        wrapMe: function () {},
+      };
+      obj.wrapMe.__original = function () {};
+      obj.wrapMe.__unwrap = function () {};
+      obj.wrapMe.__wrapped = true;
+
+      assert.deepStrictEqual(isWrapped(obj.wrapMe), true);
+    });
+  });
+  describe('when function is NOT wrapped', () => {
+    it('should return false', () => {
+      const obj: any = {
+        wrapMe: function () {},
+      };
+      obj.wrapMe.__unwrap = function () {};
+      obj.wrapMe.__wrapped = true;
+
+      assert.deepStrictEqual(isWrapped(obj.wrapMe), false);
+    });
+  });
+});