diff --git a/examples/tracer-web/README.md b/examples/tracer-web/README.md
index ec60ac8422..fef2af26b4 100644
--- a/examples/tracer-web/README.md
+++ b/examples/tracer-web/README.md
@@ -1,7 +1,6 @@
 # Overview
 
-This example shows how to use [@opentelemetry/web](https://github.com/open-telemetry/opentelemetry-js/tree/master/packages/opentelemetry-web) to instrument your JavaScript code running in the browser.
-This example uses the `ConsoleSpanExporter()` to export spans to the browser console output.
+This example shows how to use [@opentelemetry/web](https://github.com/open-telemetry/opentelemetry-js/tree/master/packages/opentelemetry-web) with different plugins and setup to instrument your JavaScript code running in the browser.
 
 ## Installation
 
@@ -19,11 +18,23 @@ $ npm start
 
 By default, the application will run on port `8090`.
 
-To see the results, open the browser at <http://localhost:8090/> and make sure you have the browser console open. The application is using the `ConsoleSpanExporter` and will post the created spans to the browser console.
+## Examples
+
+### Document Load
+
+To see the results, open the browser at <http://localhost:8090/document-load/> and make sure you have the browser console open. The application is using the `ConsoleSpanExporter` and will post the created spans to the browser console.
 
 The screen will look as follows:
 
-![Screenshot of the running example](images/traces.png)
+![Screenshot of the running example](images/document-load.png)
+
+### XMLHttpRequest
+
+To see the results, open the browser at <http://localhost:8090/xml-http-request/> and make sure you have the browser console open. The application is using the `ConsoleSpanExporter` and will post the created spans to the browser console.
+The screen will look as follows:
+
+![Screenshot of the running example](images/xml-http-request.png)
+
 
 ## Useful links
 
diff --git a/examples/tracer-web/index.html b/examples/tracer-web/examples/document-load/index.html
similarity index 88%
rename from examples/tracer-web/index.html
rename to examples/tracer-web/examples/document-load/index.html
index 395281f3e8..772a215769 100644
--- a/examples/tracer-web/index.html
+++ b/examples/tracer-web/examples/document-load/index.html
@@ -3,7 +3,7 @@
 
 <head>
   <meta charset="utf-8">
-  <title>Web Tracer Example</title>
+  <title>Document Load Plugin Example</title>
   <base href="/">
 
   <!--
@@ -22,7 +22,7 @@
 
 <body>
   Example of using Web Tracer with document load plugin with console exporter and collector exporter
-  <script type="text/javascript" src="/bundle.js"></script>
+  <script type="text/javascript" src="document-load.js"></script>
   <br/>
   <button id="button1">Test WebTracer with ZoneScopeManager - async</button>
 
diff --git a/examples/tracer-web/index.js b/examples/tracer-web/examples/document-load/index.js
similarity index 97%
rename from examples/tracer-web/index.js
rename to examples/tracer-web/examples/document-load/index.js
index c08a3c0f39..63e07e8054 100644
--- a/examples/tracer-web/index.js
+++ b/examples/tracer-web/examples/document-load/index.js
@@ -80,6 +80,4 @@ const getData = (url) => {
   });
 };
 
-window.addEventListener('load', () => {
-  prepareClickEvent();
-});
+window.addEventListener('load', prepareClickEvent);
diff --git a/examples/tracer-web/examples/xml-http-request/index.html b/examples/tracer-web/examples/xml-http-request/index.html
new file mode 100644
index 0000000000..6aa0c561fb
--- /dev/null
+++ b/examples/tracer-web/examples/xml-http-request/index.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="utf-8">
+  <title>XMLHttpRequest Plugin Example</title>
+  <base href="/">
+
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+</head>
+
+<body>
+  Example of using Web Tracer with XMLHttpRequest plugin with console exporter and collector exporter
+  <script type="text/javascript" src="xml-http-request.js"></script>
+  <br/>
+  <button id="button1">Test</button>
+
+</body>
+
+</html>
diff --git a/examples/tracer-web/examples/xml-http-request/index.js b/examples/tracer-web/examples/xml-http-request/index.js
new file mode 100644
index 0000000000..9e5ff9d2e3
--- /dev/null
+++ b/examples/tracer-web/examples/xml-http-request/index.js
@@ -0,0 +1,61 @@
+'use strict';
+
+import { ConsoleSpanExporter, SimpleSpanProcessor } from '@opentelemetry/tracing';
+import { WebTracer } from '@opentelemetry/web';
+import { XMLHttpRequestPlugin } from '@opentelemetry/plugin-xml-http-request';
+import { ZoneScopeManager } from '@opentelemetry/scope-zone';
+import { CollectorExporter } from '@opentelemetry/exporter-collector';
+import { B3Format } from '@opentelemetry/core';
+
+const webTracerWithZone = new WebTracer({
+  httpTextFormat: new B3Format(),
+  scopeManager: new ZoneScopeManager(),
+  plugins: [
+    new XMLHttpRequestPlugin({
+      ignoreUrls: [/localhost:8090\/sockjs-node/],
+      propagateTraceHeaderCorsUrls: [
+        'https://httpbin.org/get'
+      ]
+    })
+  ]
+});
+
+webTracerWithZone.addSpanProcessor(new SimpleSpanProcessor(new ConsoleSpanExporter()));
+webTracerWithZone.addSpanProcessor(new SimpleSpanProcessor(new CollectorExporter()));
+
+// example of keeping track of scope between async operations
+const prepareClickEvent = () => {
+  const url1 = 'https://httpbin.org/get';
+
+  const element = document.getElementById('button1');
+
+  const onClick = () => {
+    for (let i = 0, j = 5; i < j; i++) {
+      const span1 = webTracerWithZone.startSpan(`files-series-info-${i}`, {
+        parent: webTracerWithZone.getCurrentSpan()
+      });
+      webTracerWithZone.withSpan(span1, () => {
+        getData(url1).then((data) => {
+          webTracerWithZone.getCurrentSpan().addEvent('fetching-span1-completed');
+          span1.end();
+        });
+      });
+    }
+  };
+  element.addEventListener('click', onClick);
+};
+
+const getData = (url) => {
+  return new Promise(async (resolve, reject) => {
+    const req = new XMLHttpRequest();
+    req.open('GET', url, true);
+    req.setRequestHeader('Content-Type', 'application/json');
+    req.setRequestHeader('Accept', 'application/json');
+    req.send();
+    req.onload = function () {
+      resolve();
+    };
+  });
+};
+
+window.addEventListener('load', prepareClickEvent);
diff --git a/examples/tracer-web/images/traces.png b/examples/tracer-web/images/document-load.png
similarity index 100%
rename from examples/tracer-web/images/traces.png
rename to examples/tracer-web/images/document-load.png
diff --git a/examples/tracer-web/images/xml-http-request.png b/examples/tracer-web/images/xml-http-request.png
new file mode 100644
index 0000000000..640dcd7669
Binary files /dev/null and b/examples/tracer-web/images/xml-http-request.png differ
diff --git a/examples/tracer-web/package.json b/examples/tracer-web/package.json
index 9c9785eb02..0afe85a835 100644
--- a/examples/tracer-web/package.json
+++ b/examples/tracer-web/package.json
@@ -5,7 +5,7 @@
   "description": "Example of using @opentelemetry/web in browser",
   "main": "index.js",
   "scripts": {
-    "start": "webpack-dev-server -d --progress --colors --port 8090 --config webpack.config.js --hot --inline --host 0.0.0.0"
+    "start": "webpack-dev-server -d --progress --colors --port 8090 --config webpack.config.js --hot --inline --host 0.0.0.0 --content-base examples"
   },
   "repository": {
     "type": "git",
@@ -36,6 +36,7 @@
   "dependencies": {
     "@opentelemetry/exporter-collector": "^0.3.0",
     "@opentelemetry/plugin-document-load": "^0.3.0",
+    "@opentelemetry/plugin-xml-http-request": "^0.3.0",
     "@opentelemetry/scope-zone": "^0.3.0",
     "@opentelemetry/tracing": "^0.3.0",
     "@opentelemetry/web": "^0.3.0"
diff --git a/examples/tracer-web/webpack.config.js b/examples/tracer-web/webpack.config.js
index 0c4efe02b2..a73bffb8e6 100644
--- a/examples/tracer-web/webpack.config.js
+++ b/examples/tracer-web/webpack.config.js
@@ -1,12 +1,19 @@
 const webpack = require('webpack');
 const webpackMerge = require('webpack-merge');
 const path = require('path');
-const mainPath = path.resolve('');
 const directory = path.resolve(__dirname);
 
 const common = {
   mode: 'development',
-  entry: 'index.js',
+  entry: {
+    'document-load': 'examples/document-load/index.js',
+    'xml-http-request': 'examples/xml-http-request/index.js'
+  },
+  output: {
+    path: path.resolve(__dirname, 'dist'),
+    filename: '[name].js',
+    sourceMapFilename: '[file].map'
+  },
   target: 'web',
   module: {
     rules: [
@@ -28,7 +35,6 @@ const common = {
   },
   resolve: {
     modules: [
-      path.resolve(mainPath, 'src'),
       path.resolve(directory),
       'node_modules'
     ],
@@ -38,12 +44,8 @@ const common = {
 
 module.exports = webpackMerge(common, {
   devtool: 'eval-source-map',
-  output: {
-    filename: 'bundle.js',
-    sourceMapFilename: '[file].map'
-  },
   devServer: {
-    contentBase: path.resolve(__dirname),
+    contentBase: path.resolve(__dirname)
   },
   plugins: [
     new webpack.DefinePlugin({
diff --git a/packages/opentelemetry-core/src/common/types.ts b/packages/opentelemetry-core/src/common/types.ts
index d765535031..eb84ba58b7 100644
--- a/packages/opentelemetry-core/src/common/types.ts
+++ b/packages/opentelemetry-core/src/common/types.ts
@@ -32,3 +32,13 @@ export interface TimeOriginLegacy {
     fetchStart: number;
   };
 }
+
+/**
+ * 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;
+}
diff --git a/packages/opentelemetry-core/src/index.ts b/packages/opentelemetry-core/src/index.ts
index 236ad9d2cd..ab8a031b70 100644
--- a/packages/opentelemetry-core/src/index.ts
+++ b/packages/opentelemetry-core/src/index.ts
@@ -33,3 +33,5 @@ export * from './trace/spancontext-utils';
 export * from './trace/TracerDelegate';
 export * from './trace/TraceState';
 export * from './metrics/NoopMeter';
+export * from './utils/url';
+export * from './utils/wrap';
diff --git a/packages/opentelemetry-core/src/utils/url.ts b/packages/opentelemetry-core/src/utils/url.ts
new file mode 100644
index 0000000000..8ed779bca2
--- /dev/null
+++ b/packages/opentelemetry-core/src/utils/url.ts
@@ -0,0 +1,48 @@
+/*!
+ * Copyright 2019, 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.
+ */
+
+/**
+ * Check if {@param url} matches {@param urlToMatch}
+ * @param url
+ * @param urlToMatch
+ */
+export function urlMatches(url: string, urlToMatch: string | RegExp): boolean {
+  if (typeof urlToMatch === 'string') {
+    return url === urlToMatch;
+  } else {
+    return !!url.match(urlToMatch);
+  }
+}
+/**
+ * Check if {@param url} should be ignored when comparing against {@param ignoredUrls}
+ * @param url
+ * @param ignoredUrls
+ */
+export function isUrlIgnored(
+  url: string,
+  ignoredUrls?: Array<string | RegExp>
+): boolean {
+  if (!ignoredUrls) {
+    return false;
+  }
+
+  for (const ignoreUrl of ignoredUrls) {
+    if (urlMatches(url, ignoreUrl)) {
+      return true;
+    }
+  }
+  return false;
+}
diff --git a/packages/opentelemetry-core/src/utils/wrap.ts b/packages/opentelemetry-core/src/utils/wrap.ts
new file mode 100644
index 0000000000..ad3ac6b4c3
--- /dev/null
+++ b/packages/opentelemetry-core/src/utils/wrap.ts
@@ -0,0 +1,30 @@
+/*!
+ * Copyright 2019, 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 { ShimWrapped } from '../common/types';
+
+/**
+ * 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
+  );
+}
diff --git a/packages/opentelemetry-core/test/utils/url.test.ts b/packages/opentelemetry-core/test/utils/url.test.ts
new file mode 100644
index 0000000000..205ec9aa07
--- /dev/null
+++ b/packages/opentelemetry-core/test/utils/url.test.ts
@@ -0,0 +1,75 @@
+/**
+ * Copyright 2019, 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 { isUrlIgnored } from '../../src';
+
+const urlIgnored = 'url should be ignored';
+const urlNotIgnored = 'url should NOT be ignored';
+
+const urlToTest = 'http://myaddress.com/somepath';
+
+describe('BasePlugin - Utils', () => {
+  describe('isUrlIgnored', () => {
+    describe('when ignored urls are undefined', () => {
+      it('should return false', () => {
+        assert.strictEqual(isUrlIgnored(urlToTest), false, urlNotIgnored);
+      });
+    });
+    describe('when ignored urls are empty', () => {
+      it('should return false', () => {
+        assert.strictEqual(isUrlIgnored(urlToTest, []), false, urlNotIgnored);
+      });
+    });
+    describe('when ignored urls is the same as url', () => {
+      it('should return true', () => {
+        assert.strictEqual(
+          isUrlIgnored(urlToTest, ['http://myaddress.com/somepath']),
+          true,
+          urlIgnored
+        );
+      });
+    });
+    describe('when url is part of ignored urls', () => {
+      it('should return false', () => {
+        assert.strictEqual(
+          isUrlIgnored(urlToTest, ['http://myaddress.com/some']),
+          false,
+          urlNotIgnored
+        );
+      });
+    });
+    describe('when ignored urls is part of url - REGEXP', () => {
+      it('should return true', () => {
+        assert.strictEqual(
+          isUrlIgnored(urlToTest, [/.+?myaddress\.com/]),
+          true,
+          urlIgnored
+        );
+      });
+    });
+    describe('when url is part of ignored urls - REGEXP', () => {
+      it('should return false', () => {
+        assert.strictEqual(
+          isUrlIgnored(urlToTest, [/http:\/\/myaddress\.com\/somepath2/]),
+          false,
+          urlNotIgnored
+        );
+      });
+    });
+  });
+});
diff --git a/packages/opentelemetry-core/test/utils/wrap.test.ts b/packages/opentelemetry-core/test/utils/wrap.test.ts
new file mode 100644
index 0000000000..741edc96b2
--- /dev/null
+++ b/packages/opentelemetry-core/test/utils/wrap.test.ts
@@ -0,0 +1,81 @@
+/**
+ * Copyright 2019, 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, ShimWrapped } from '../../src';
+
+function makeWrapped(
+  wrapped: unknown,
+  unwrap: any,
+  original: any
+): ShimWrapped {
+  const wrapper = function() {};
+  defineProperty(wrapper, '__wrapped', wrapped);
+  defineProperty(wrapper, '__unwrap', unwrap);
+  defineProperty(wrapper, '__original', original);
+  return (wrapper as unknown) as ShimWrapped;
+}
+
+function defineProperty(obj: any, name: string, value: unknown) {
+  var enumerable = !!obj[name] && obj.propertyIsEnumerable(name);
+  Object.defineProperty(obj, name, {
+    configurable: true,
+    enumerable: enumerable,
+    writable: true,
+    value: value,
+  });
+}
+
+const notWrappedFunctions: any[] = [];
+notWrappedFunctions.push(
+  makeWrapped(
+    false,
+    function() {},
+    function() {}
+  )
+);
+notWrappedFunctions.push(makeWrapped(false, 'foo', function() {}));
+notWrappedFunctions.push(makeWrapped(false, function() {}, 'foo'));
+notWrappedFunctions.push({
+  __wrapped: true,
+  __unwrap: function() {},
+  __original: function() {},
+});
+
+describe('utils-wrap', () => {
+  describe('isWrapped', () => {
+    it('should return true when function was wrapped', () => {
+      const wrapped: ShimWrapped = makeWrapped(
+        true,
+        function() {},
+        function() {}
+      );
+      assert.strictEqual(isWrapped(wrapped), true, 'function is not wrapped');
+    });
+
+    it('should return false when function is not wrapped', () => {
+      notWrappedFunctions.forEach((wrapped: unknown, index: number) => {
+        const result = isWrapped(wrapped as ShimWrapped);
+        assert.strictEqual(
+          result,
+          false,
+          `function number #${index} is wrapped`
+        );
+      });
+    });
+  });
+});
diff --git a/packages/opentelemetry-plugin-document-load/src/documentLoad.ts b/packages/opentelemetry-plugin-document-load/src/documentLoad.ts
index 4ca569a54d..208b7d151b 100644
--- a/packages/opentelemetry-plugin-document-load/src/documentLoad.ts
+++ b/packages/opentelemetry-plugin-document-load/src/documentLoad.ts
@@ -22,9 +22,13 @@ import {
 } from '@opentelemetry/core';
 import { PluginConfig, Span, SpanOptions } from '@opentelemetry/types';
 import { AttributeNames } from './enums/AttributeNames';
-import { PerformanceTimingNames as PTN } from './enums/PerformanceTimingNames';
-import { PerformanceEntries, PerformanceLegacy } from './types';
-import { hasKey } from './utils';
+import {
+  addSpanNetworkEvent,
+  hasKey,
+  PerformanceEntries,
+  PerformanceLegacy,
+  PerformanceTimingNames as PTN,
+} from '@opentelemetry/web';
 
 /**
  * This class represents a document load plugin
@@ -73,45 +77,19 @@ export class DocumentLoad extends BasePlugin<unknown> {
     }
   }
 
-  /**
-   * Helper function for starting an event
-   * @param span
-   * @param performanceName name of performance entry for time start
-   * @param entries
-   */
-  private _addSpanEvent(
-    span: Span,
-    performanceName: string,
-    entries: PerformanceEntries
-  ): Span | undefined {
-    if (
-      hasKey(entries, performanceName) &&
-      typeof entries[performanceName] === 'number'
-    ) {
-      // some metrics are available but have value 0 which means they are invalid
-      // for example "secureConnectionStart" is 0 which makes the events to be wrongly interpreted
-      if (entries[performanceName] === 0) {
-        return undefined;
-      }
-      span.addEvent(performanceName, entries[performanceName]);
-      return span;
-    }
-    return undefined;
-  }
-
   /**
    * Adds span network events
    * @param span
    * @param entries entries that contains performance information about resource
    */
   private _addSpanNetworkEvents(span: Span, entries: PerformanceEntries) {
-    this._addSpanEvent(span, PTN.DOMAIN_LOOKUP_START, entries);
-    this._addSpanEvent(span, PTN.DOMAIN_LOOKUP_END, entries);
-    this._addSpanEvent(span, PTN.CONNECT_START, entries);
-    this._addSpanEvent(span, PTN.SECURE_CONNECTION_START, entries);
-    this._addSpanEvent(span, PTN.CONNECT_END, entries);
-    this._addSpanEvent(span, PTN.REQUEST_START, entries);
-    this._addSpanEvent(span, PTN.RESPONSE_START, entries);
+    addSpanNetworkEvent(span, PTN.DOMAIN_LOOKUP_START, entries);
+    addSpanNetworkEvent(span, PTN.DOMAIN_LOOKUP_END, entries);
+    addSpanNetworkEvent(span, PTN.CONNECT_START, entries);
+    addSpanNetworkEvent(span, PTN.SECURE_CONNECTION_START, entries);
+    addSpanNetworkEvent(span, PTN.CONNECT_END, entries);
+    addSpanNetworkEvent(span, PTN.REQUEST_START, entries);
+    addSpanNetworkEvent(span, PTN.RESPONSE_START, entries);
   }
 
   /**
@@ -148,13 +126,13 @@ export class DocumentLoad extends BasePlugin<unknown> {
 
     this._addResourcesSpans(rootSpan);
 
-    this._addSpanEvent(rootSpan, PTN.UNLOAD_EVENT_START, entries);
-    this._addSpanEvent(rootSpan, PTN.UNLOAD_EVENT_END, entries);
-    this._addSpanEvent(rootSpan, PTN.DOM_INTERACTIVE, entries);
-    this._addSpanEvent(rootSpan, PTN.DOM_CONTENT_LOADED_EVENT_START, entries);
-    this._addSpanEvent(rootSpan, PTN.DOM_CONTENT_LOADED_EVENT_END, entries);
-    this._addSpanEvent(rootSpan, PTN.DOM_COMPLETE, entries);
-    this._addSpanEvent(rootSpan, PTN.LOAD_EVENT_START, entries);
+    addSpanNetworkEvent(rootSpan, PTN.UNLOAD_EVENT_START, entries);
+    addSpanNetworkEvent(rootSpan, PTN.UNLOAD_EVENT_END, entries);
+    addSpanNetworkEvent(rootSpan, PTN.DOM_INTERACTIVE, entries);
+    addSpanNetworkEvent(rootSpan, PTN.DOM_CONTENT_LOADED_EVENT_START, entries);
+    addSpanNetworkEvent(rootSpan, PTN.DOM_CONTENT_LOADED_EVENT_END, entries);
+    addSpanNetworkEvent(rootSpan, PTN.DOM_COMPLETE, entries);
+    addSpanNetworkEvent(rootSpan, PTN.LOAD_EVENT_START, entries);
 
     this._endSpan(rootSpan, PTN.LOAD_EVENT_END, entries);
   }
@@ -173,7 +151,7 @@ export class DocumentLoad extends BasePlugin<unknown> {
     // span can be undefined when entries are missing the certain performance - the span will not be created
     if (span) {
       if (hasKey(entries, performanceName)) {
-        this._addSpanEvent(span, performanceName, entries);
+        addSpanNetworkEvent(span, performanceName, entries);
         span.end(entries[performanceName]);
       } else {
         // just end span
@@ -269,7 +247,7 @@ export class DocumentLoad extends BasePlugin<unknown> {
         )
       );
       span.setAttribute(AttributeNames.COMPONENT, this.component);
-      this._addSpanEvent(span, performanceName, entries);
+      addSpanNetworkEvent(span, performanceName, entries);
       return span;
     }
     return undefined;
diff --git a/packages/opentelemetry-plugin-document-load/test/documentLoad.test.ts b/packages/opentelemetry-plugin-document-load/test/documentLoad.test.ts
index cb17ceb566..c125ae8402 100644
--- a/packages/opentelemetry-plugin-document-load/test/documentLoad.test.ts
+++ b/packages/opentelemetry-plugin-document-load/test/documentLoad.test.ts
@@ -32,7 +32,7 @@ import { Logger, PluginConfig, TimedEvent } from '@opentelemetry/types';
 
 import { ExportResult } from '../../opentelemetry-base/build/src';
 import { DocumentLoad } from '../src';
-import { PerformanceTimingNames as PTN } from '../src/enums/PerformanceTimingNames';
+import { PerformanceTimingNames as PTN } from '@opentelemetry/web';
 
 export class DummyExporter implements SpanExporter {
   export(
diff --git a/packages/opentelemetry-plugin-xml-http-request/.npmignore b/packages/opentelemetry-plugin-xml-http-request/.npmignore
new file mode 100644
index 0000000000..9505ba9450
--- /dev/null
+++ b/packages/opentelemetry-plugin-xml-http-request/.npmignore
@@ -0,0 +1,4 @@
+/bin
+/coverage
+/doc
+/test
diff --git a/packages/opentelemetry-plugin-xml-http-request/LICENSE b/packages/opentelemetry-plugin-xml-http-request/LICENSE
new file mode 100644
index 0000000000..261eeb9e9f
--- /dev/null
+++ b/packages/opentelemetry-plugin-xml-http-request/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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
+
+       http://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.
diff --git a/packages/opentelemetry-plugin-xml-http-request/README.md b/packages/opentelemetry-plugin-xml-http-request/README.md
new file mode 100644
index 0000000000..e647c8a6b0
--- /dev/null
+++ b/packages/opentelemetry-plugin-xml-http-request/README.md
@@ -0,0 +1,64 @@
+# OpenTelemetry XMLHttpRequest Instrumentation for web
+[![Gitter chat][gitter-image]][gitter-url]
+[![NPM Published Version][npm-img]][npm-url]
+[![dependencies][dependencies-image]][dependencies-url]
+[![devDependencies][devDependencies-image]][devDependencies-url]
+[![Apache License][license-image]][license-image]
+
+This module provides auto instrumentation for web using XMLHttpRequest .
+
+## Installation
+
+```bash
+npm install --save @opentelemetry/plugin-xml-http-request
+```
+
+## Usage
+
+```js
+import { ConsoleSpanExporter, SimpleSpanProcessor } from '@opentelemetry/tracing';
+import { WebTracer } from '@opentelemetry/web';
+import { XMLHttpRequestPlugin } from '@opentelemetry/plugin-xml-http-request';
+import { ZoneScopeManager } from '@opentelemetry/scope-zone';
+
+const webTracerWithZone = new WebTracer({
+  scopeManager: new ZoneScopeManager(),
+  plugins: [
+    new XMLHttpRequestPlugin({
+      propagateTraceHeaderCorsUrls: ['http://localhost:8090']    
+    })
+  ]
+});
+webTracerWithZone.addSpanProcessor(new SimpleSpanProcessor(new ConsoleSpanExporter()));
+
+// and some test
+const req = new XMLHttpRequest();
+req.open('GET', 'http://localhost:8090/xml-http-request.js', true);
+req.send();
+
+```
+
+## Example Screenshots
+![Screenshot of the running example](images/main.jpg)
+![Screenshot of the running example](images/request.jpg)
+![Screenshot of the running example](images/cors.jpg)
+
+## Useful links
+- For more information on OpenTelemetry, visit: <https://opentelemetry.io/>
+- For more about OpenTelemetry JavaScript: <https://github.com/open-telemetry/opentelemetry-js>
+- For help or feedback on this project, join us on [gitter][gitter-url]
+
+## License
+
+Apache 2.0 - See [LICENSE][license-url] for more information.
+
+[gitter-image]: https://badges.gitter.im/open-telemetry/opentelemetry-js.svg
+[gitter-url]: https://gitter.im/open-telemetry/opentelemetry-node?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+[license-url]: https://github.com/open-telemetry/opentelemetry-js/blob/master/LICENSE
+[license-image]: https://img.shields.io/badge/license-Apache_2.0-green.svg?style=flat
+[dependencies-image]: https://david-dm.org/open-telemetry/opentelemetry-js/status.svg?path=packages/opentelemetry-plugin-xml-http-request
+[dependencies-url]: https://david-dm.org/open-telemetry/opentelemetry-js?path=packages%2Fopentelemetry-plugin-xml-http-request
+[devDependencies-image]: https://david-dm.org/open-telemetry/opentelemetry-js/dev-status.svg?path=packages/opentelemetry-plugin-xml-http-request
+[devDependencies-url]: https://david-dm.org/open-telemetry/opentelemetry-js?path=packages%2Fopentelemetry-plugin-xml-http-request&type=dev
+[npm-url]: https://www.npmjs.com/package/@opentelemetry/plugin-xml-http-request
+[npm-img]: https://badge.fury.io/js/%40opentelemetry%plugin-xml-http-request.svg
diff --git a/packages/opentelemetry-plugin-xml-http-request/images/cors.jpg b/packages/opentelemetry-plugin-xml-http-request/images/cors.jpg
new file mode 100644
index 0000000000..634eeb4fc8
Binary files /dev/null and b/packages/opentelemetry-plugin-xml-http-request/images/cors.jpg differ
diff --git a/packages/opentelemetry-plugin-xml-http-request/images/main.jpg b/packages/opentelemetry-plugin-xml-http-request/images/main.jpg
new file mode 100644
index 0000000000..1c1e18d33c
Binary files /dev/null and b/packages/opentelemetry-plugin-xml-http-request/images/main.jpg differ
diff --git a/packages/opentelemetry-plugin-xml-http-request/images/request.jpg b/packages/opentelemetry-plugin-xml-http-request/images/request.jpg
new file mode 100644
index 0000000000..01adad7b8e
Binary files /dev/null and b/packages/opentelemetry-plugin-xml-http-request/images/request.jpg differ
diff --git a/packages/opentelemetry-plugin-xml-http-request/karma.conf.js b/packages/opentelemetry-plugin-xml-http-request/karma.conf.js
new file mode 100644
index 0000000000..7183aab033
--- /dev/null
+++ b/packages/opentelemetry-plugin-xml-http-request/karma.conf.js
@@ -0,0 +1,24 @@
+/*!
+ * Copyright 2019, 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
+ *
+ *      http://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.
+ */
+
+const karmaWebpackConfig = require('../../karma.webpack');
+const karmaBaseConfig = require('../../karma.base');
+
+module.exports = (config) => {
+  config.set(Object.assign({}, karmaBaseConfig, {
+    webpack: karmaWebpackConfig
+  }))
+};
diff --git a/packages/opentelemetry-plugin-xml-http-request/package.json b/packages/opentelemetry-plugin-xml-http-request/package.json
new file mode 100644
index 0000000000..447737ea52
--- /dev/null
+++ b/packages/opentelemetry-plugin-xml-http-request/package.json
@@ -0,0 +1,84 @@
+{
+  "name": "@opentelemetry/plugin-xml-http-request",
+  "version": "0.3.0",
+  "description": "OpenTelemetry XMLHttpRequest automatic instrumentation package.",
+  "main": "build/src/index.js",
+  "types": "build/src/index.d.ts",
+  "repository": "open-telemetry/opentelemetry-js",
+  "scripts": {
+    "check": "gts check",
+    "clean": "rimraf build/*",
+    "codecov:browser": "nyc report --reporter=json && codecov -f coverage/*.json -p ../../",
+    "precompile": "tsc --version",
+    "compile": "tsc -p .",
+    "fix": "gts fix",
+    "prepare": "npm run compile",
+    "tdd": "karma start",
+    "test:browser": "nyc karma start --single-run",
+    "watch": "tsc -w"
+  },
+  "keywords": [
+    "opentelemetry",
+    "browser",
+    "tracing",
+    "profiling",
+    "metrics",
+    "XMLHttpRequest",
+    "stats"
+  ],
+  "author": "OpenTelemetry Authors",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=8.0.0"
+  },
+  "files": [
+    "build/src/**/*.js",
+    "build/src/**/*.d.ts",
+    "doc",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.6.0",
+    "@types/mocha": "^5.2.5",
+    "@types/node": "^12.6.8",
+    "@types/shimmer": "^1.0.1",
+    "@types/sinon": "^7.0.13",
+    "@types/webpack-env": "1.13.9",
+    "babel-loader": "^8.0.6",
+    "codecov": "^3.1.0",
+    "gts": "^1.0.0",
+    "istanbul-instrumenter-loader": "^3.0.1",
+    "karma": "^4.4.1",
+    "karma-chrome-launcher": "^3.1.0",
+    "karma-coverage-istanbul-reporter": "^2.1.0",
+    "karma-mocha": "^1.3.0",
+    "karma-spec-reporter": "^0.0.32",
+    "karma-webpack": "^4.0.2",
+    "mocha": "^6.1.0",
+    "nyc": "^14.1.1",
+    "rimraf": "^3.0.0",
+    "sinon": "^7.5.0",
+    "ts-loader": "^6.0.4",
+    "ts-mocha": "^6.0.0",
+    "ts-node": "^8.0.0",
+    "tslint-consistent-codestyle": "^1.16.0",
+    "tslint-microsoft-contrib": "^6.2.0",
+    "typescript": "3.6.4",
+    "webpack": "^4.35.2",
+    "webpack-cli": "^3.3.9",
+    "webpack-merge": "^4.2.2",
+    "@opentelemetry/scope-zone": "^0.3.0",
+    "@opentelemetry/tracing": "^0.3.0"
+  },
+  "dependencies": {
+    "@opentelemetry/base": "^0.3.0",
+    "@opentelemetry/core": "^0.3.0",
+    "@opentelemetry/types": "^0.3.0",
+    "@opentelemetry/web": "^0.3.0",
+    "shimmer": "^1.2.1"
+  }
+}
diff --git a/packages/opentelemetry-plugin-xml-http-request/src/enums/AttributeNames.ts b/packages/opentelemetry-plugin-xml-http-request/src/enums/AttributeNames.ts
new file mode 100644
index 0000000000..64112652d5
--- /dev/null
+++ b/packages/opentelemetry-plugin-xml-http-request/src/enums/AttributeNames.ts
@@ -0,0 +1,31 @@
+/*!
+ * Copyright 2019, 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.
+ */
+
+/**
+ * https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/data-http.md#common-attributes
+ */
+export enum AttributeNames {
+  COMPONENT = 'component',
+  HTTP_HOST = 'http.host',
+  HTTP_FLAVOR = 'http.flavor',
+  HTTP_METHOD = 'http.method',
+  HTTP_SCHEME = 'http.scheme',
+  HTTP_STATUS_CODE = 'http.status_code',
+  HTTP_STATUS_TEXT = 'http.status_text',
+  HTTP_URL = 'http.url',
+  // NOT ON OFFICIAL SPEC
+  HTTP_USER_AGENT = 'http.user_agent',
+}
diff --git a/packages/opentelemetry-plugin-document-load/src/utils.ts b/packages/opentelemetry-plugin-xml-http-request/src/enums/EventNames.ts
similarity index 73%
rename from packages/opentelemetry-plugin-document-load/src/utils.ts
rename to packages/opentelemetry-plugin-xml-http-request/src/enums/EventNames.ts
index cb585de753..c3edf96cea 100644
--- a/packages/opentelemetry-plugin-document-load/src/utils.ts
+++ b/packages/opentelemetry-plugin-xml-http-request/src/enums/EventNames.ts
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-/**
- * Helper function to be able to use enum as typed key in type and in interface when using forEach
- * @param obj
- * @param key
- */
-export function hasKey<O>(obj: O, key: keyof any): key is keyof O {
-  return key in obj;
+export enum EventNames {
+  METHOD_OPEN = 'open',
+  METHOD_SEND = 'send',
+  EVENT_ABORT = 'abort',
+  EVENT_ERROR = 'error',
+  EVENT_LOAD = 'loaded',
+  EVENT_TIMEOUT = 'timeout',
 }
diff --git a/packages/opentelemetry-plugin-xml-http-request/src/enums/Format.ts b/packages/opentelemetry-plugin-xml-http-request/src/enums/Format.ts
new file mode 100644
index 0000000000..c67b1c54da
--- /dev/null
+++ b/packages/opentelemetry-plugin-xml-http-request/src/enums/Format.ts
@@ -0,0 +1,19 @@
+/*!
+ * Copyright 2019, 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.
+ */
+
+export enum Format {
+  HTTP = 'HttpTraceContext',
+}
diff --git a/packages/opentelemetry-plugin-xml-http-request/src/index.ts b/packages/opentelemetry-plugin-xml-http-request/src/index.ts
new file mode 100644
index 0000000000..41f752b023
--- /dev/null
+++ b/packages/opentelemetry-plugin-xml-http-request/src/index.ts
@@ -0,0 +1,17 @@
+/*!
+ * Copyright 2019, 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.
+ */
+
+export * from './xhr';
diff --git a/packages/opentelemetry-plugin-xml-http-request/src/types.ts b/packages/opentelemetry-plugin-xml-http-request/src/types.ts
new file mode 100644
index 0000000000..92c64f982f
--- /dev/null
+++ b/packages/opentelemetry-plugin-xml-http-request/src/types.ts
@@ -0,0 +1,72 @@
+/*!
+ * Copyright 2019, 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 types from '@opentelemetry/types';
+
+/**
+ * method "open" from XMLHttpRequest
+ */
+export type OpenFunction = (
+  method: string,
+  url: string,
+  async?: boolean,
+  user?: string | null,
+  pass?: string | null
+) => void;
+
+/**
+ * method "send" from XMLHttpRequest
+ */
+export type SendFunction = (body?: SendBody) => void;
+
+export type SendBody =
+  | string
+  | Document
+  | Blob
+  | ArrayBufferView
+  | ArrayBuffer
+  | FormData
+  | URLSearchParams
+  | ReadableStream<Uint8Array>
+  | null;
+
+/**
+ * interface to store information in weak map about spans, resources and
+ * callbacks
+ */
+export interface XhrMem {
+  status?: number;
+  statusText?: string;
+  // span assigned to xhr
+  span: types.Span;
+  // span url - not available on types.Span
+  spanUrl?: string;
+  // startTime of send function - used to filter cors preflight requests
+  sendStartTime?: types.HrTime;
+  // resources created between send and end plus some additional timeout
+  createdResources?: {
+    observer: PerformanceObserver;
+    entries: PerformanceResourceTiming[];
+  };
+  // callback to remove events from xhr once the span ends
+  callbackToRemoveEvents?: Function;
+}
+
+export type PropagateTraceHeaderCorsUrl = string | RegExp;
+
+export type PropagateTraceHeaderCorsUrls =
+  | PropagateTraceHeaderCorsUrl
+  | PropagateTraceHeaderCorsUrl[];
diff --git a/packages/opentelemetry-plugin-xml-http-request/src/xhr.ts b/packages/opentelemetry-plugin-xml-http-request/src/xhr.ts
new file mode 100644
index 0000000000..46a8f61c39
--- /dev/null
+++ b/packages/opentelemetry-plugin-xml-http-request/src/xhr.ts
@@ -0,0 +1,534 @@
+/*!
+ * Copyright 2019, 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 {
+  BasePlugin,
+  hrTime,
+  isUrlIgnored,
+  isWrapped,
+  otperformance,
+  urlMatches,
+} from '@opentelemetry/core';
+import * as types from '@opentelemetry/types';
+import {
+  addSpanNetworkEvent,
+  getResource,
+  parseUrl,
+  PerformanceTimingNames as PTN,
+} from '@opentelemetry/web';
+import * as shimmer from 'shimmer';
+import { AttributeNames } from './enums/AttributeNames';
+import { EventNames } from './enums/EventNames';
+import { Format } from './enums/Format';
+import {
+  OpenFunction,
+  PropagateTraceHeaderCorsUrls,
+  SendFunction,
+  XhrMem,
+} from './types';
+
+// how long to wait for observer to collect information about resources
+// this is needed as event "load" is called before observer
+// hard to say how long it should really wait, seems like 300ms is
+// safe enough
+const OBSERVER_WAIT_TIME_MS = 300;
+
+/**
+ * XMLHttpRequest config
+ */
+export interface XMLHttpRequestPluginConfig extends types.PluginConfig {
+  // the number of timing resources is limited, after the limit
+  // (chrome 250, safari 150) the information is not collected anymore
+  // the only way to prevent that is to regularly clean the resources
+  // whenever it is possible, this is needed only when PerformanceObserver
+  // is not available
+  clearTimingResources?: boolean;
+  // urls which should include trace headers when origin doesn't match
+  propagateTraceHeaderCorsUrls?: PropagateTraceHeaderCorsUrls;
+}
+
+/**
+ * This class represents a XMLHttpRequest plugin for auto instrumentation
+ */
+export class XMLHttpRequestPlugin extends BasePlugin<XMLHttpRequest> {
+  readonly component: string = 'xml-http-request';
+  // @TODO align this with all packages #600
+  readonly version: string = '0.3.0';
+  moduleName = this.component;
+
+  protected _config!: XMLHttpRequestPluginConfig;
+
+  private _tasksCount = 0;
+  private _xhrMem = new WeakMap<XMLHttpRequest, XhrMem>();
+  private _usedResources = new WeakSet<PerformanceResourceTiming>();
+
+  constructor(config: XMLHttpRequestPluginConfig = {}) {
+    super();
+    this._config = config;
+  }
+
+  /**
+   * Adds custom headers to XMLHttpRequest
+   * @param xhr
+   * @param span
+   * @private
+   */
+  private _addHeaders(xhr: XMLHttpRequest, span: types.Span, spanUrl: string) {
+    if (!this._shouldPropagateTraceHeaders(spanUrl)) {
+      return;
+    }
+    const headers: { [key: string]: unknown } = {};
+    this._tracer
+      .getHttpTextFormat()
+      .inject(span.context(), Format.HTTP, headers);
+
+    Object.keys(headers).forEach(key => {
+      xhr.setRequestHeader(key, String(headers[key]));
+    });
+  }
+
+  /**
+   * checks if trace headers shoudl be propagated
+   * @param spanUrl
+   * @private
+   */
+  _shouldPropagateTraceHeaders(spanUrl: string) {
+    let propagateTraceHeaderUrls =
+      this._config.propagateTraceHeaderCorsUrls || [];
+    if (
+      typeof propagateTraceHeaderUrls === 'string' ||
+      propagateTraceHeaderUrls instanceof RegExp
+    ) {
+      propagateTraceHeaderUrls = [propagateTraceHeaderUrls];
+    }
+    const parsedSpanUrl = parseUrl(spanUrl);
+
+    if (parsedSpanUrl.origin === window.location.origin) {
+      return true;
+    } else {
+      for (const propagateTraceHeaderUrl of propagateTraceHeaderUrls) {
+        if (urlMatches(spanUrl, propagateTraceHeaderUrl)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Add cors pre flight child span
+   * @param span
+   * @param corsPreFlightRequest
+   * @private
+   */
+  private _addChildSpan(
+    span: types.Span,
+    corsPreFlightRequest: PerformanceResourceTiming
+  ): void {
+    const childSpan = this._tracer.startSpan('CORS Preflight', {
+      startTime: corsPreFlightRequest[PTN.FETCH_START],
+      parent: span,
+    }) as types.Span;
+    this._addSpanNetworkEvents(childSpan, corsPreFlightRequest);
+    childSpan.end(corsPreFlightRequest[PTN.RESPONSE_END]);
+  }
+
+  /**
+   * Add attributes when span is going to end
+   * @param span
+   * @param xhr
+   * @param spanUrl
+   * @private
+   */
+  _addFinalSpanAttributes(span: types.Span, xhrMem: XhrMem, spanUrl?: string) {
+    if (typeof spanUrl === 'string') {
+      const parsedUrl = parseUrl(spanUrl);
+
+      span.setAttribute(AttributeNames.HTTP_STATUS_CODE, xhrMem.status);
+      span.setAttribute(AttributeNames.HTTP_STATUS_TEXT, xhrMem.statusText);
+      span.setAttribute(AttributeNames.HTTP_HOST, parsedUrl.host);
+      span.setAttribute(
+        AttributeNames.HTTP_SCHEME,
+        parsedUrl.protocol.replace(':', '')
+      );
+
+      // @TODO do we want to collect this or it will be collected earlier once only or
+      //    maybe when parent span is not available ?
+      span.setAttribute(AttributeNames.HTTP_USER_AGENT, navigator.userAgent);
+    }
+  }
+
+  /**
+   * Adds Network events to the span
+   * @param span
+   * @param resource
+   * @private
+   */
+  private _addSpanNetworkEvents(
+    span: types.Span,
+    resource: PerformanceResourceTiming
+  ) {
+    addSpanNetworkEvent(span, PTN.FETCH_START, resource);
+    addSpanNetworkEvent(span, PTN.DOMAIN_LOOKUP_START, resource);
+    addSpanNetworkEvent(span, PTN.DOMAIN_LOOKUP_END, resource);
+    addSpanNetworkEvent(span, PTN.CONNECT_START, resource);
+    addSpanNetworkEvent(span, PTN.SECURE_CONNECTION_START, resource);
+    addSpanNetworkEvent(span, PTN.CONNECT_END, resource);
+    addSpanNetworkEvent(span, PTN.REQUEST_START, resource);
+    addSpanNetworkEvent(span, PTN.RESPONSE_START, resource);
+    addSpanNetworkEvent(span, PTN.RESPONSE_END, resource);
+  }
+
+  /**
+   * will collect information about all resources created
+   * between "send" and "end" with additional waiting for main resource
+   * @param xhr
+   * @param spanUrl
+   * @private
+   */
+  private _addResourceObserver(xhr: XMLHttpRequest, spanUrl: string) {
+    const xhrMem = this._xhrMem.get(xhr);
+    if (!xhrMem || typeof window.PerformanceObserver === 'undefined') {
+      return;
+    }
+    xhrMem.createdResources = {
+      observer: new PerformanceObserver(list => {
+        const entries = list.getEntries() as PerformanceResourceTiming[];
+        entries.forEach(entry => {
+          if (
+            entry.initiatorType === 'xmlhttprequest' &&
+            entry.name === spanUrl
+          ) {
+            if (xhrMem.createdResources) {
+              xhrMem.createdResources.entries.push(entry);
+            }
+          }
+        });
+      }),
+      entries: [],
+    };
+    xhrMem.createdResources.observer.observe({
+      entryTypes: ['resource'],
+    });
+  }
+
+  /**
+   * Clears the resource timings and all resources assigned with spans
+   *     when {@link XMLHttpRequestPluginConfig.clearTimingResources} is
+   *     set to true (default false)
+   * @private
+   */
+  private _clearResources() {
+    if (this._tasksCount === 0 && this._config.clearTimingResources) {
+      ((otperformance as unknown) as Performance).clearResourceTimings();
+      this._xhrMem = new WeakMap<XMLHttpRequest, XhrMem>();
+      this._usedResources = new WeakSet<PerformanceResourceTiming>();
+    }
+  }
+
+  /**
+   * Finds appropriate resource and add network events to the span
+   * @param span
+   */
+  private _findResourceAndAddNetworkEvents(
+    xhrMem: XhrMem,
+    span: types.Span,
+    spanUrl?: string,
+    startTime?: types.HrTime,
+    endTime?: types.HrTime
+  ): void {
+    if (!spanUrl || !startTime || !endTime || !xhrMem.createdResources) {
+      return;
+    }
+
+    let resources: PerformanceResourceTiming[] =
+      xhrMem.createdResources.entries;
+
+    if (!resources || !resources.length) {
+      // fallback - either Observer is not available or it took longer
+      // then OBSERVER_WAIT_TIME_MS and observer didn't collect enough
+      // information
+      resources = otperformance.getEntriesByType(
+        'resource'
+      ) as PerformanceResourceTiming[];
+    }
+
+    const resource = getResource(
+      spanUrl,
+      startTime,
+      endTime,
+      resources,
+      this._usedResources
+    );
+
+    if (resource.mainRequest) {
+      const mainRequest = resource.mainRequest;
+      this._markResourceAsUsed(mainRequest);
+
+      const corsPreFlightRequest = resource.corsPreFlightRequest;
+      if (corsPreFlightRequest) {
+        this._addChildSpan(span, corsPreFlightRequest);
+        this._markResourceAsUsed(corsPreFlightRequest);
+      }
+      this._addSpanNetworkEvents(span, mainRequest);
+    }
+  }
+
+  /**
+   * Removes the previous information about span.
+   * This might happened when the same xhr is used again.
+   * @param xhr
+   * @private
+   */
+  private _cleanPreviousSpanInformation(xhr: XMLHttpRequest) {
+    const xhrMem = this._xhrMem.get(xhr);
+    if (xhrMem) {
+      const callbackToRemoveEvents = xhrMem.callbackToRemoveEvents;
+      if (callbackToRemoveEvents) {
+        callbackToRemoveEvents();
+      }
+      this._xhrMem.delete(xhr);
+    }
+  }
+
+  /**
+   * Creates a new span when method "open" is called
+   * @param xhr
+   * @param url
+   * @param method
+   * @private
+   */
+  private _createSpan(
+    xhr: XMLHttpRequest,
+    url: string,
+    method: string
+  ): types.Span | undefined {
+    if (isUrlIgnored(url, this._config.ignoreUrls)) {
+      this._logger.debug('ignoring span as url matches ignored url');
+      return;
+    }
+
+    const currentSpan = this._tracer.startSpan(url, {
+      parent: this._tracer.getCurrentSpan(),
+      attributes: {
+        [AttributeNames.COMPONENT]: this.component,
+        [AttributeNames.HTTP_METHOD]: method,
+        [AttributeNames.HTTP_URL]: url,
+      },
+    });
+
+    currentSpan.addEvent(EventNames.METHOD_OPEN);
+
+    this._cleanPreviousSpanInformation(xhr);
+
+    this._xhrMem.set(xhr, {
+      span: currentSpan,
+      spanUrl: url,
+    });
+
+    return currentSpan;
+  }
+
+  /**
+   * Marks certain [resource]{@link PerformanceResourceTiming} when information
+   * from this is used to add events to span.
+   * This is done to avoid reusing the same resource again for next span
+   * @param resource
+   * @private
+   */
+  private _markResourceAsUsed(resource: PerformanceResourceTiming) {
+    this._usedResources.add(resource);
+  }
+
+  /**
+   * Patches the method open
+   * @private
+   */
+  protected _patchOpen() {
+    return (original: OpenFunction): OpenFunction => {
+      const plugin = this;
+      return function patchOpen(this: XMLHttpRequest, ...args): void {
+        const method: string = args[0];
+        const url: string = args[1];
+        const async: boolean = !!args[2];
+        if (async) {
+          plugin._createSpan(this, url, method);
+        } else {
+          plugin._logger.debug(
+            'tracing support for synchronous XMLHttpRequest calls is not' +
+              ' supported'
+          );
+        }
+
+        return original.apply(this, args);
+      };
+    };
+  }
+
+  /**
+   * Patches the method send
+   * @private
+   */
+  protected _patchSend() {
+    const plugin = this;
+
+    function endSpanTimeout(
+      eventName: string,
+      xhrMem: XhrMem,
+      endTime: types.HrTime
+    ) {
+      const callbackToRemoveEvents = xhrMem.callbackToRemoveEvents;
+
+      if (typeof callbackToRemoveEvents === 'function') {
+        callbackToRemoveEvents();
+      }
+
+      const { span, spanUrl, sendStartTime } = xhrMem;
+
+      if (span) {
+        plugin._findResourceAndAddNetworkEvents(
+          xhrMem,
+          span,
+          spanUrl,
+          sendStartTime,
+          endTime
+        );
+        span.addEvent(eventName, endTime);
+        plugin._addFinalSpanAttributes(span, xhrMem, spanUrl);
+        span.end(endTime);
+        plugin._tasksCount--;
+      }
+      plugin._clearResources();
+    }
+
+    function endSpan(eventName: string, xhr: XMLHttpRequest) {
+      const xhrMem = plugin._xhrMem.get(xhr);
+      if (!xhrMem) {
+        return;
+      }
+      xhrMem.status = xhr.status;
+      xhrMem.statusText = xhr.statusText;
+      plugin._xhrMem.delete(xhr);
+      const endTime = hrTime();
+
+      // the timeout is needed as observer doesn't have yet information
+      // when event "load" is called. Also the time may differ depends on
+      // browser and speed of computer
+      setTimeout(() => {
+        endSpanTimeout(eventName, xhrMem, endTime);
+      }, OBSERVER_WAIT_TIME_MS);
+    }
+
+    function onError(this: XMLHttpRequest) {
+      endSpan(EventNames.EVENT_ERROR, this);
+    }
+
+    function onAbort(this: XMLHttpRequest) {
+      endSpan(EventNames.EVENT_ABORT, this);
+    }
+
+    function onTimeout(this: XMLHttpRequest) {
+      endSpan(EventNames.EVENT_TIMEOUT, this);
+    }
+
+    function onLoad(this: XMLHttpRequest) {
+      if (this.status < 299) {
+        endSpan(EventNames.EVENT_LOAD, this);
+      } else {
+        endSpan(EventNames.EVENT_ERROR, this);
+      }
+    }
+
+    function unregister(xhr: XMLHttpRequest) {
+      xhr.removeEventListener('abort', onAbort);
+      xhr.removeEventListener('error', onError);
+      xhr.removeEventListener('load', onLoad);
+      xhr.removeEventListener('timeout', onTimeout);
+      const xhrMem = plugin._xhrMem.get(xhr);
+      if (xhrMem) {
+        xhrMem.callbackToRemoveEvents = undefined;
+      }
+    }
+
+    return (original: SendFunction): SendFunction => {
+      return function patchSend(this: XMLHttpRequest, ...args): void {
+        const xhrMem = plugin._xhrMem.get(this);
+        if (!xhrMem) {
+          return original.apply(this, args);
+        }
+        const currentSpan = xhrMem.span;
+        const spanUrl = xhrMem.spanUrl;
+
+        if (currentSpan && spanUrl) {
+          plugin._tasksCount++;
+          xhrMem.sendStartTime = hrTime();
+          currentSpan.addEvent(EventNames.METHOD_SEND);
+
+          this.addEventListener('abort', onAbort);
+          this.addEventListener('error', onError);
+          this.addEventListener('load', onLoad);
+          this.addEventListener('timeout', onTimeout);
+
+          xhrMem.callbackToRemoveEvents = () => {
+            unregister(this);
+            if (xhrMem.createdResources) {
+              xhrMem.createdResources.observer.disconnect();
+            }
+          };
+          plugin._addHeaders(this, currentSpan, spanUrl);
+          plugin._addResourceObserver(this, spanUrl);
+        }
+        return original.apply(this, args);
+      };
+    };
+  }
+
+  /**
+   * implements patch function
+   */
+  protected patch() {
+    this._logger.debug('applying patch to', this.moduleName, this.version);
+
+    if (isWrapped(XMLHttpRequest.prototype.open)) {
+      shimmer.unwrap(XMLHttpRequest.prototype, 'open');
+      this._logger.debug('removing previous patch from method open');
+    }
+
+    if (isWrapped(XMLHttpRequest.prototype.send)) {
+      shimmer.unwrap(XMLHttpRequest.prototype, 'send');
+      this._logger.debug('removing previous patch from method send');
+    }
+
+    shimmer.wrap(XMLHttpRequest.prototype, 'open', this._patchOpen());
+    shimmer.wrap(XMLHttpRequest.prototype, 'send', this._patchSend());
+
+    return this._moduleExports;
+  }
+
+  /**
+   * implements unpatch function
+   */
+  protected unpatch() {
+    this._logger.debug('removing patch from', this.moduleName, this.version);
+
+    shimmer.unwrap(XMLHttpRequest.prototype, 'open');
+    shimmer.unwrap(XMLHttpRequest.prototype, 'send');
+
+    this._tasksCount = 0;
+    this._xhrMem = new WeakMap<XMLHttpRequest, XhrMem>();
+    this._usedResources = new WeakSet<PerformanceResourceTiming>();
+  }
+}
diff --git a/packages/opentelemetry-plugin-xml-http-request/test/index-webpack.ts b/packages/opentelemetry-plugin-xml-http-request/test/index-webpack.ts
new file mode 100644
index 0000000000..7731f09091
--- /dev/null
+++ b/packages/opentelemetry-plugin-xml-http-request/test/index-webpack.ts
@@ -0,0 +1,23 @@
+/*!
+ * Copyright 2019, 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.
+ */
+
+// This file is the webpack entry point for the browser Karma tests. It requires
+// all modules ending in "test" from the current folder and all its subfolders.
+const testsContext = require.context('.', true, /test$/);
+testsContext.keys().forEach(testsContext);
+
+const srcContext = require.context('.', true, /src$/);
+srcContext.keys().forEach(srcContext);
diff --git a/packages/opentelemetry-plugin-xml-http-request/test/xhr.test.ts b/packages/opentelemetry-plugin-xml-http-request/test/xhr.test.ts
new file mode 100644
index 0000000000..2d920b0bfb
--- /dev/null
+++ b/packages/opentelemetry-plugin-xml-http-request/test/xhr.test.ts
@@ -0,0 +1,585 @@
+/*!
+ * Copyright 2019, 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 * as sinon from 'sinon';
+
+import {
+  B3Format,
+  LogLevel,
+  otperformance as performance,
+  X_B3_SAMPLED,
+  X_B3_SPAN_ID,
+  X_B3_TRACE_ID,
+} from '@opentelemetry/core';
+import { ZoneScopeManager } from '@opentelemetry/scope-zone';
+import * as tracing from '@opentelemetry/tracing';
+import * as types from '@opentelemetry/types';
+import { PerformanceTimingNames as PTN, WebTracer } from '@opentelemetry/web';
+import { AttributeNames } from '../src/enums/AttributeNames';
+import { EventNames } from '../src/enums/EventNames';
+import { XMLHttpRequestPlugin } from '../src/xhr';
+
+class DummySpanExporter implements tracing.SpanExporter {
+  export(spans: any) {}
+
+  shutdown() {}
+}
+
+const getData = (url: string, callbackAfterSend: Function) => {
+  return new Promise(async (resolve, reject) => {
+    const req = new XMLHttpRequest();
+    req.open('GET', url, true);
+    req.send();
+    req.onload = function() {
+      resolve();
+    };
+
+    req.onerror = function() {
+      resolve();
+    };
+
+    req.ontimeout = function() {
+      resolve();
+    };
+
+    callbackAfterSend();
+  });
+};
+
+function createResource(resource = {}): PerformanceResourceTiming {
+  const defaultResource = {
+    connectEnd: 15,
+    connectStart: 13,
+    decodedBodySize: 0,
+    domainLookupEnd: 12,
+    domainLookupStart: 11,
+    encodedBodySize: 0,
+    fetchStart: 10.1,
+    initiatorType: 'xmlhttprequest',
+    nextHopProtocol: '',
+    redirectEnd: 0,
+    redirectStart: 0,
+    requestStart: 16,
+    responseEnd: 80.5,
+    responseStart: 17,
+    secureConnectionStart: 14,
+    transferSize: 0,
+    workerStart: 0,
+    duration: 0,
+    entryType: '',
+    name: '',
+    startTime: 0,
+  };
+  return Object.assign(
+    {},
+    defaultResource,
+    resource
+  ) as PerformanceResourceTiming;
+}
+
+describe('xhr', () => {
+  let sandbox: sinon.SinonSandbox;
+  let requests: any[] = [];
+  let prepareData: any;
+  let clearData: any;
+
+  describe('when request is successful', () => {
+    let webTracerWithZone: WebTracer;
+    let dummySpanExporter: DummySpanExporter;
+    let exportSpy: any;
+    let rootSpan: types.Span;
+    let spyEntries: any;
+    const url = `${window.location.origin}/xml-http-request.js`;
+    let fakeNow = 0;
+
+    clearData = () => {
+      requests = [];
+      sandbox.restore();
+      spyEntries.restore();
+    };
+
+    prepareData = (
+      done: any,
+      fileUrl: string,
+      propagateTraceHeaderCorsUrls?: any
+    ) => {
+      sandbox = sinon.createSandbox();
+      const fakeXhr = sandbox.useFakeXMLHttpRequest();
+      fakeXhr.onCreate = function(xhr: any) {
+        requests.push(xhr);
+      };
+      sandbox.useFakeTimers();
+
+      sandbox.stub(performance, 'timeOrigin').value(0);
+      sandbox.stub(performance, 'now').callsFake(() => fakeNow);
+
+      const resources: PerformanceResourceTiming[] = [];
+      resources.push(
+        createResource({
+          name: url,
+        })
+      );
+
+      spyEntries = sandbox.stub(performance, 'getEntriesByType');
+      spyEntries.withArgs('resource').returns(resources);
+
+      webTracerWithZone = new WebTracer({
+        logLevel: LogLevel.ERROR,
+        httpTextFormat: new B3Format(),
+        scopeManager: new ZoneScopeManager(),
+        plugins: [
+          new XMLHttpRequestPlugin({
+            propagateTraceHeaderCorsUrls: propagateTraceHeaderCorsUrls,
+          }),
+        ],
+      });
+      dummySpanExporter = new DummySpanExporter();
+      exportSpy = sinon.stub(dummySpanExporter, 'export');
+      webTracerWithZone.addSpanProcessor(
+        new tracing.SimpleSpanProcessor(dummySpanExporter)
+      );
+
+      rootSpan = webTracerWithZone.startSpan('root');
+
+      webTracerWithZone.withSpan(rootSpan, () => {
+        getData(fileUrl, () => {
+          fakeNow = 100;
+        }).then(() => {
+          fakeNow = 0;
+          sandbox.clock.tick(1000);
+          done();
+        });
+        assert.strictEqual(requests.length, 1, 'request not called');
+
+        requests[0].respond(
+          200,
+          { 'Content-Type': 'application/json' },
+          '{"foo":"bar"}'
+        );
+      });
+    };
+
+    beforeEach(done => {
+      const propagateTraceHeaderCorsUrls = [window.location.origin];
+      prepareData(done, url, propagateTraceHeaderCorsUrls);
+    });
+
+    afterEach(() => {
+      clearData();
+    });
+
+    it('current span should be root span', () => {
+      assert.strictEqual(
+        webTracerWithZone.getCurrentSpan(),
+        rootSpan,
+        'root span is wrong'
+      );
+    });
+
+    it('should create a span with correct root span', () => {
+      const span: tracing.ReadableSpan = exportSpy.args[0][0][0];
+      assert.strictEqual(
+        span.parentSpanId,
+        rootSpan.context().spanId,
+        'parent span is not root span'
+      );
+    });
+
+    it('span should have correct name', () => {
+      const span: tracing.ReadableSpan = exportSpy.args[0][0][0];
+      assert.strictEqual(span.name, url, 'span has wrong name');
+    });
+
+    it('span should have correct attributes', () => {
+      const span: tracing.ReadableSpan = exportSpy.args[0][0][0];
+      const attributes = span.attributes;
+      const keys = Object.keys(attributes);
+
+      assert.ok(
+        attributes[keys[0]] !== '',
+        `attributes ${AttributeNames.COMPONENT} is not defined`
+      );
+      assert.strictEqual(
+        attributes[keys[1]],
+        'GET',
+        `attributes ${AttributeNames.HTTP_METHOD} is wrong`
+      );
+      assert.strictEqual(
+        attributes[keys[2]],
+        url,
+        `attributes ${AttributeNames.HTTP_URL} is wrong`
+      );
+      assert.strictEqual(
+        attributes[keys[3]],
+        200,
+        `attributes ${AttributeNames.HTTP_STATUS_CODE} is wrong`
+      );
+      assert.strictEqual(
+        attributes[keys[4]],
+        'OK',
+        `attributes ${AttributeNames.HTTP_STATUS_TEXT} is wrong`
+      );
+      assert.strictEqual(
+        attributes[keys[5]],
+        window.location.host,
+        `attributes ${AttributeNames.HTTP_HOST} is wrong`
+      );
+      assert.ok(
+        attributes[keys[6]] === 'http' || attributes[keys[6]] === 'https',
+        `attributes ${AttributeNames.HTTP_SCHEME} is wrong`
+      );
+      assert.ok(
+        attributes[keys[7]] !== '',
+        `attributes ${AttributeNames.HTTP_USER_AGENT} is not defined`
+      );
+
+      assert.strictEqual(keys.length, 8, 'number of attributes is wrong');
+    });
+
+    it('span should have correct events', () => {
+      const span: tracing.ReadableSpan = exportSpy.args[0][0][0];
+      const events = span.events;
+
+      assert.strictEqual(
+        events[0].name,
+        EventNames.METHOD_OPEN,
+        `event ${EventNames.METHOD_OPEN} is not defined`
+      );
+      assert.strictEqual(
+        events[1].name,
+        EventNames.METHOD_SEND,
+        `event ${EventNames.METHOD_SEND} is not defined`
+      );
+      assert.strictEqual(
+        events[2].name,
+        PTN.FETCH_START,
+        `event ${PTN.FETCH_START} is not defined`
+      );
+      assert.strictEqual(
+        events[3].name,
+        PTN.DOMAIN_LOOKUP_START,
+        `event ${PTN.DOMAIN_LOOKUP_START} is not defined`
+      );
+      assert.strictEqual(
+        events[4].name,
+        PTN.DOMAIN_LOOKUP_END,
+        `event ${PTN.DOMAIN_LOOKUP_END} is not defined`
+      );
+      assert.strictEqual(
+        events[5].name,
+        PTN.CONNECT_START,
+        `event ${PTN.CONNECT_START} is not defined`
+      );
+      assert.strictEqual(
+        events[6].name,
+        PTN.SECURE_CONNECTION_START,
+        `event ${PTN.SECURE_CONNECTION_START} is not defined`
+      );
+      assert.strictEqual(
+        events[7].name,
+        PTN.CONNECT_END,
+        `event ${PTN.CONNECT_END} is not defined`
+      );
+      assert.strictEqual(
+        events[8].name,
+        PTN.REQUEST_START,
+        `event ${PTN.REQUEST_START} is not defined`
+      );
+      assert.strictEqual(
+        events[9].name,
+        PTN.RESPONSE_START,
+        `event ${PTN.RESPONSE_START} is not defined`
+      );
+      assert.strictEqual(
+        events[10].name,
+        PTN.RESPONSE_END,
+        `event ${PTN.RESPONSE_END} is not defined`
+      );
+      assert.strictEqual(
+        events[11].name,
+        EventNames.EVENT_LOAD,
+        `event ${EventNames.EVENT_LOAD} is not defined`
+      );
+
+      assert.strictEqual(events.length, 12, 'number of events is wrong');
+    });
+
+    describe('AND origin match with window.location', () => {
+      it('should set trace headers', () => {
+        const span: types.Span = exportSpy.args[0][0][0];
+        assert.strictEqual(
+          requests[0].requestHeaders[X_B3_TRACE_ID],
+          span.context().traceId,
+          `trace header '${X_B3_TRACE_ID}' not set`
+        );
+        assert.strictEqual(
+          requests[0].requestHeaders[X_B3_SPAN_ID],
+          span.context().spanId,
+          `trace header '${X_B3_SPAN_ID}' not set`
+        );
+        assert.strictEqual(
+          requests[0].requestHeaders[X_B3_SAMPLED],
+          String(span.context().traceFlags),
+          `trace header '${X_B3_SAMPLED}' not set`
+        );
+      });
+    });
+
+    describe(
+      'AND origin does NOT match window.location but match with' +
+        ' propagateTraceHeaderCorsUrls',
+      () => {
+        beforeEach(done => {
+          clearData();
+          prepareData(
+            done,
+            'https://raw.githubusercontent.com/open-telemetry/opentelemetry-js/master/package.json',
+            /raw\.githubusercontent\.com/
+          );
+        });
+        it('should set trace headers', () => {
+          const span: types.Span = exportSpy.args[0][0][0];
+          assert.strictEqual(
+            requests[0].requestHeaders[X_B3_TRACE_ID],
+            span.context().traceId,
+            `trace header '${X_B3_TRACE_ID}' not set`
+          );
+          assert.strictEqual(
+            requests[0].requestHeaders[X_B3_SPAN_ID],
+            span.context().spanId,
+            `trace header '${X_B3_SPAN_ID}' not set`
+          );
+          assert.strictEqual(
+            requests[0].requestHeaders[X_B3_SAMPLED],
+            String(span.context().traceFlags),
+            `trace header '${X_B3_SAMPLED}' not set`
+          );
+        });
+      }
+    );
+    describe(
+      'AND origin does NOT match window.location And does NOT match' +
+        ' with propagateTraceHeaderCorsUrls',
+      () => {
+        beforeEach(done => {
+          clearData();
+          prepareData(
+            done,
+            'https://raw.githubusercontent.com/open-telemetry/opentelemetry-js/master/package.json'
+          );
+        });
+        it('should NOT set trace headers', () => {
+          assert.strictEqual(
+            requests[0].requestHeaders[X_B3_TRACE_ID],
+            undefined,
+            `trace header '${X_B3_TRACE_ID}' should not be set`
+          );
+          assert.strictEqual(
+            requests[0].requestHeaders[X_B3_SPAN_ID],
+            undefined,
+            `trace header '${X_B3_SPAN_ID}' should not be set`
+          );
+          assert.strictEqual(
+            requests[0].requestHeaders[X_B3_SAMPLED],
+            undefined,
+            `trace header '${X_B3_SAMPLED}' should not be set`
+          );
+        });
+      }
+    );
+  });
+
+  describe('when request is NOT successful', () => {
+    let webTracerWithZone: WebTracer;
+    let dummySpanExporter: DummySpanExporter;
+    let exportSpy: any;
+    let rootSpan: types.Span;
+    let spyEntries: any;
+    const url =
+      'https://raw.githubusercontent.com/open-telemetry/opentelemetry-js/master/package.json';
+    let fakeNow = 0;
+
+    beforeEach(done => {
+      sandbox = sinon.createSandbox();
+      const fakeXhr = sandbox.useFakeXMLHttpRequest();
+      fakeXhr.onCreate = function(xhr: any) {
+        requests.push(xhr);
+      };
+
+      sandbox.useFakeTimers();
+
+      sandbox.stub(performance, 'timeOrigin').value(0);
+      sandbox.stub(performance, 'now').callsFake(() => fakeNow);
+
+      const resources: PerformanceResourceTiming[] = [];
+      resources.push(
+        createResource({
+          name: url,
+        })
+      );
+
+      spyEntries = sandbox.stub(performance, 'getEntriesByType');
+      spyEntries.withArgs('resource').returns(resources);
+
+      webTracerWithZone = new WebTracer({
+        logLevel: LogLevel.ERROR,
+        scopeManager: new ZoneScopeManager(),
+        plugins: [new XMLHttpRequestPlugin()],
+      });
+      dummySpanExporter = new DummySpanExporter();
+      exportSpy = sinon.stub(dummySpanExporter, 'export');
+      webTracerWithZone.addSpanProcessor(
+        new tracing.SimpleSpanProcessor(dummySpanExporter)
+      );
+
+      rootSpan = webTracerWithZone.startSpan('root');
+
+      webTracerWithZone.withSpan(rootSpan, () => {
+        getData(url, () => {
+          fakeNow = 100;
+        }).then(() => {
+          fakeNow = 0;
+          sandbox.clock.tick(1000);
+          done();
+        });
+        assert.strictEqual(requests.length, 1, 'request not called');
+        requests[0].respond(
+          400,
+          { 'Content-Type': 'text/plain' },
+          'Bad Request'
+        );
+      });
+    });
+
+    afterEach(() => {
+      clearData();
+    });
+
+    it('span should have correct attributes', () => {
+      const span: tracing.ReadableSpan = exportSpy.args[0][0][0];
+      const attributes = span.attributes;
+      const keys = Object.keys(attributes);
+
+      assert.ok(
+        attributes[keys[0]] !== '',
+        `attributes ${AttributeNames.COMPONENT} is not defined`
+      );
+      assert.strictEqual(
+        attributes[keys[1]],
+        'GET',
+        `attributes ${AttributeNames.HTTP_METHOD} is wrong`
+      );
+      assert.strictEqual(
+        attributes[keys[2]],
+        url,
+        `attributes ${AttributeNames.HTTP_URL} is wrong`
+      );
+      assert.strictEqual(
+        attributes[keys[3]],
+        400,
+        `attributes ${AttributeNames.HTTP_STATUS_CODE} is wrong`
+      );
+      assert.strictEqual(
+        attributes[keys[4]],
+        'Bad Request',
+        `attributes ${AttributeNames.HTTP_STATUS_TEXT} is wrong`
+      );
+      assert.strictEqual(
+        attributes[keys[5]],
+        'raw.githubusercontent.com',
+        `attributes ${AttributeNames.HTTP_HOST} is wrong`
+      );
+      assert.ok(
+        attributes[keys[6]] === 'http' || attributes[keys[6]] === 'https',
+        `attributes ${AttributeNames.HTTP_SCHEME} is wrong`
+      );
+      assert.ok(
+        attributes[keys[7]] !== '',
+        `attributes ${AttributeNames.HTTP_USER_AGENT} is not defined`
+      );
+
+      assert.strictEqual(keys.length, 8, 'number of attributes is wrong');
+    });
+
+    it('span should have correct events', () => {
+      const span: tracing.ReadableSpan = exportSpy.args[0][0][0];
+      const events = span.events;
+
+      assert.strictEqual(
+        events[0].name,
+        EventNames.METHOD_OPEN,
+        `event ${EventNames.METHOD_OPEN} is not defined`
+      );
+      assert.strictEqual(
+        events[1].name,
+        EventNames.METHOD_SEND,
+        `event ${EventNames.METHOD_SEND} is not defined`
+      );
+      assert.strictEqual(
+        events[2].name,
+        PTN.FETCH_START,
+        `event ${PTN.FETCH_START} is not defined`
+      );
+      assert.strictEqual(
+        events[3].name,
+        PTN.DOMAIN_LOOKUP_START,
+        `event ${PTN.DOMAIN_LOOKUP_START} is not defined`
+      );
+      assert.strictEqual(
+        events[4].name,
+        PTN.DOMAIN_LOOKUP_END,
+        `event ${PTN.DOMAIN_LOOKUP_END} is not defined`
+      );
+      assert.strictEqual(
+        events[5].name,
+        PTN.CONNECT_START,
+        `event ${PTN.CONNECT_START} is not defined`
+      );
+      assert.strictEqual(
+        events[6].name,
+        PTN.SECURE_CONNECTION_START,
+        `event ${PTN.SECURE_CONNECTION_START} is not defined`
+      );
+      assert.strictEqual(
+        events[7].name,
+        PTN.CONNECT_END,
+        `event ${PTN.CONNECT_END} is not defined`
+      );
+      assert.strictEqual(
+        events[8].name,
+        PTN.REQUEST_START,
+        `event ${PTN.REQUEST_START} is not defined`
+      );
+      assert.strictEqual(
+        events[9].name,
+        PTN.RESPONSE_START,
+        `event ${PTN.RESPONSE_START} is not defined`
+      );
+      assert.strictEqual(
+        events[10].name,
+        PTN.RESPONSE_END,
+        `event ${PTN.RESPONSE_END} is not defined`
+      );
+      assert.strictEqual(
+        events[11].name,
+        EventNames.EVENT_ERROR,
+        `event ${EventNames.EVENT_ERROR} is not defined`
+      );
+
+      assert.strictEqual(events.length, 12, 'number of events is wrong');
+    });
+  });
+});
diff --git a/packages/opentelemetry-plugin-xml-http-request/tsconfig-release.json b/packages/opentelemetry-plugin-xml-http-request/tsconfig-release.json
new file mode 100644
index 0000000000..ffc0f77968
--- /dev/null
+++ b/packages/opentelemetry-plugin-xml-http-request/tsconfig-release.json
@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "types": []
+  },
+  "include": ["src/**/*.ts"]
+}
diff --git a/packages/opentelemetry-plugin-xml-http-request/tsconfig.json b/packages/opentelemetry-plugin-xml-http-request/tsconfig.json
new file mode 100644
index 0000000000..a2042cd68b
--- /dev/null
+++ b/packages/opentelemetry-plugin-xml-http-request/tsconfig.json
@@ -0,0 +1,11 @@
+{
+  "extends": "../tsconfig.base",
+  "compilerOptions": {
+    "rootDir": ".",
+    "outDir": "build"
+  },
+  "include": [
+    "src/**/*.ts",
+    "test/**/*.ts"
+  ]
+}
diff --git a/packages/opentelemetry-plugin-xml-http-request/tslint.json b/packages/opentelemetry-plugin-xml-http-request/tslint.json
new file mode 100644
index 0000000000..0710b135d0
--- /dev/null
+++ b/packages/opentelemetry-plugin-xml-http-request/tslint.json
@@ -0,0 +1,4 @@
+{
+  "rulesDirectory": ["node_modules/tslint-microsoft-contrib"],
+  "extends": ["../../tslint.base.js", "./node_modules/tslint-consistent-codestyle"]
+}
diff --git a/packages/opentelemetry-web/src/WebTracer.ts b/packages/opentelemetry-web/src/WebTracer.ts
index 5d3fad465e..b71c53ef4b 100644
--- a/packages/opentelemetry-web/src/WebTracer.ts
+++ b/packages/opentelemetry-web/src/WebTracer.ts
@@ -48,7 +48,7 @@ export class WebTracer extends BasicTracer {
     config.scopeManager.enable();
 
     for (const plugin of config.plugins) {
-      plugin.enable([], this, this.logger, {});
+      plugin.enable([], this, this.logger);
     }
   }
 }
diff --git a/packages/opentelemetry-plugin-document-load/src/enums/PerformanceTimingNames.ts b/packages/opentelemetry-web/src/enums/PerformanceTimingNames.ts
similarity index 100%
rename from packages/opentelemetry-plugin-document-load/src/enums/PerformanceTimingNames.ts
rename to packages/opentelemetry-web/src/enums/PerformanceTimingNames.ts
diff --git a/packages/opentelemetry-web/src/index.ts b/packages/opentelemetry-web/src/index.ts
index 4b652e2a56..250c44496e 100644
--- a/packages/opentelemetry-web/src/index.ts
+++ b/packages/opentelemetry-web/src/index.ts
@@ -16,3 +16,6 @@
 
 export * from './WebTracer';
 export * from './StackScopeManager';
+export * from './enums/PerformanceTimingNames';
+export * from './types';
+export * from './utils';
diff --git a/packages/opentelemetry-plugin-document-load/src/types.ts b/packages/opentelemetry-web/src/types.ts
similarity index 87%
rename from packages/opentelemetry-plugin-document-load/src/types.ts
rename to packages/opentelemetry-web/src/types.ts
index cd99cb6e9c..be51c8ad62 100644
--- a/packages/opentelemetry-plugin-document-load/src/types.ts
+++ b/packages/opentelemetry-web/src/types.ts
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-import { PerformanceTimingNames } from './enums/PerformanceTimingNames';
-
 /**
  * Performance metrics
  */
+import { PerformanceTimingNames } from './enums/PerformanceTimingNames';
+
 export type PerformanceEntries = {
   [PerformanceTimingNames.CONNECT_END]?: number;
   [PerformanceTimingNames.CONNECT_START]?: number;
@@ -48,3 +48,12 @@ export type PerformanceEntries = {
 export interface PerformanceLegacy {
   timing?: PerformanceEntries;
 }
+
+/**
+ * This interface is used in {@link getResource} function to return
+ *     main request and it's corresponding PreFlight request
+ */
+export interface PerformanceResourceTimingInfo {
+  corsPreFlightRequest?: PerformanceResourceTiming;
+  mainRequest?: PerformanceResourceTiming;
+}
diff --git a/packages/opentelemetry-web/src/utils.ts b/packages/opentelemetry-web/src/utils.ts
new file mode 100644
index 0000000000..c1c999cbbc
--- /dev/null
+++ b/packages/opentelemetry-web/src/utils.ts
@@ -0,0 +1,232 @@
+/*!
+ * Copyright 2019, 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 { PerformanceEntries, PerformanceResourceTimingInfo } from './types';
+import { PerformanceTimingNames as PTN } from './enums/PerformanceTimingNames';
+import * as types from '@opentelemetry/types';
+import { hrTimeToNanoseconds, timeInputToHrTime } from '@opentelemetry/core';
+
+/**
+ * Helper function to be able to use enum as typed key in type and in interface when using forEach
+ * @param obj
+ * @param key
+ */
+export function hasKey<O>(obj: O, key: keyof any): key is keyof O {
+  return key in obj;
+}
+
+/**
+ * Helper function for starting an event on span based on {@link PerformanceEntries}
+ * @param span
+ * @param performanceName name of performance entry for time start
+ * @param entries
+ */
+export function addSpanNetworkEvent(
+  span: types.Span,
+  performanceName: string,
+  entries: PerformanceEntries
+): types.Span | undefined {
+  if (
+    hasKey(entries, performanceName) &&
+    typeof entries[performanceName] === 'number'
+  ) {
+    // some metrics are available but have value 0 which means they are invalid
+    // for example "secureConnectionStart" is 0 which makes the events to be wrongly interpreted
+    if (entries[performanceName] === 0) {
+      return undefined;
+    }
+    span.addEvent(performanceName, entries[performanceName]);
+    return span;
+  }
+  return undefined;
+}
+
+/**
+ * sort resources by startTime
+ * @param filteredResources
+ */
+export function sortResources(filteredResources: PerformanceResourceTiming[]) {
+  return filteredResources.slice().sort((a, b) => {
+    const valueA = a[PTN.FETCH_START];
+    const valueB = b[PTN.FETCH_START];
+    if (valueA > valueB) {
+      return 1;
+    } else if (valueA < valueB) {
+      return -1;
+    }
+    return 0;
+  });
+}
+
+/**
+ * Get closest performance resource ignoring the resources that have been
+ * already used.
+ * @param spanUrl
+ * @param startTimeHR
+ * @param endTimeHR
+ * @param resources
+ * @param ignoredResources
+ */
+export function getResource(
+  spanUrl: string,
+  startTimeHR: types.HrTime,
+  endTimeHR: types.HrTime,
+  resources: PerformanceResourceTiming[],
+  ignoredResources: WeakSet<PerformanceResourceTiming> = new WeakSet<
+    PerformanceResourceTiming
+  >()
+): PerformanceResourceTimingInfo {
+  const filteredResources = filterResourcesForSpan(
+    spanUrl,
+    startTimeHR,
+    endTimeHR,
+    resources,
+    ignoredResources
+  );
+
+  if (filteredResources.length === 0) {
+    return {
+      mainRequest: undefined,
+    };
+  }
+  if (filteredResources.length === 1) {
+    return {
+      mainRequest: filteredResources[0],
+    };
+  }
+  const sorted = sortResources(filteredResources.slice());
+
+  const parsedSpanUrl = parseUrl(spanUrl);
+  if (parsedSpanUrl.origin !== window.location.origin && sorted.length > 1) {
+    let corsPreFlightRequest: PerformanceResourceTiming | undefined = sorted[0];
+    let mainRequest: PerformanceResourceTiming = findMainRequest(
+      sorted,
+      corsPreFlightRequest[PTN.RESPONSE_END],
+      endTimeHR
+    );
+
+    const responseEnd = corsPreFlightRequest[PTN.RESPONSE_END];
+    const fetchStart = mainRequest[PTN.FETCH_START];
+
+    // no corsPreFlightRequest
+    if (fetchStart < responseEnd) {
+      mainRequest = corsPreFlightRequest;
+      corsPreFlightRequest = undefined;
+    }
+
+    return {
+      corsPreFlightRequest,
+      mainRequest,
+    };
+  } else {
+    return {
+      mainRequest: filteredResources[0],
+    };
+  }
+}
+
+/**
+ * Will find the main request skipping the cors pre flight requests
+ * @param resources
+ * @param corsPreFlightRequestEndTime
+ * @param spanEndTimeHR
+ */
+function findMainRequest(
+  resources: PerformanceResourceTiming[],
+  corsPreFlightRequestEndTime: number,
+  spanEndTimeHR: types.HrTime
+): PerformanceResourceTiming {
+  const spanEndTime = hrTimeToNanoseconds(spanEndTimeHR);
+  const minTime = hrTimeToNanoseconds(
+    timeInputToHrTime(corsPreFlightRequestEndTime)
+  );
+
+  let mainRequest: PerformanceResourceTiming = resources[1];
+  let bestGap;
+
+  const length = resources.length;
+  for (let i = 1; i < length; i++) {
+    const resource = resources[i];
+    const resourceStartTime = hrTimeToNanoseconds(
+      timeInputToHrTime(resource[PTN.FETCH_START])
+    );
+
+    const resourceEndTime = hrTimeToNanoseconds(
+      timeInputToHrTime(resource[PTN.RESPONSE_END])
+    );
+
+    const currentGap = spanEndTime - resourceEndTime;
+
+    if (resourceStartTime >= minTime && (!bestGap || currentGap < bestGap)) {
+      bestGap = currentGap;
+      mainRequest = resource;
+    }
+  }
+  return mainRequest;
+}
+
+/**
+ * Filter all resources that has started and finished according to span start time and end time.
+ *     It will return the closest resource to a start time
+ * @param spanUrl
+ * @param startTimeHR
+ * @param endTimeHR
+ * @param resources
+ * @param ignoredResources
+ */
+function filterResourcesForSpan(
+  spanUrl: string,
+  startTimeHR: types.HrTime,
+  endTimeHR: types.HrTime,
+  resources: PerformanceResourceTiming[],
+  ignoredResources: WeakSet<PerformanceResourceTiming>
+) {
+  const startTime = hrTimeToNanoseconds(startTimeHR);
+  const endTime = hrTimeToNanoseconds(endTimeHR);
+  let filteredResources = resources.filter(resource => {
+    const resourceStartTime = hrTimeToNanoseconds(
+      timeInputToHrTime(resource[PTN.FETCH_START])
+    );
+    const resourceEndTime = hrTimeToNanoseconds(
+      timeInputToHrTime(resource[PTN.RESPONSE_END])
+    );
+
+    return (
+      resource.initiatorType.toLowerCase() === 'xmlhttprequest' &&
+      resource.name === spanUrl &&
+      resourceStartTime >= startTime &&
+      resourceEndTime <= endTime
+    );
+  });
+
+  if (filteredResources.length > 0) {
+    filteredResources = filteredResources.filter(resource => {
+      return !ignoredResources.has(resource);
+    });
+  }
+
+  return filteredResources;
+}
+
+/**
+ * Parses url using anchor element
+ * @param url
+ */
+export function parseUrl(url: string): HTMLAnchorElement {
+  const a = document.createElement('a');
+  a.href = url;
+  return a;
+}
diff --git a/packages/opentelemetry-web/test/utils.test.ts b/packages/opentelemetry-web/test/utils.test.ts
new file mode 100644
index 0000000000..98d392fbec
--- /dev/null
+++ b/packages/opentelemetry-web/test/utils.test.ts
@@ -0,0 +1,386 @@
+/*!
+ * Copyright 2019, 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 {
+  hrTimeToNanoseconds,
+  otperformance as performance,
+} from '@opentelemetry/core';
+import * as core from '@opentelemetry/core';
+import * as tracing from '@opentelemetry/tracing';
+import { HrTime } from '@opentelemetry/types';
+
+import * as assert from 'assert';
+import * as sinon from 'sinon';
+import { addSpanNetworkEvent, getResource, PerformanceEntries } from '../src';
+import { PerformanceTimingNames as PTN } from '../src/enums/PerformanceTimingNames';
+
+const SECOND_TO_NANOSECONDS = 1e9;
+
+function createHrTime(startTime: HrTime, addToStart: number): HrTime {
+  let seconds = startTime[0];
+  let nanos = startTime[1] + addToStart;
+  if (nanos >= SECOND_TO_NANOSECONDS) {
+    nanos = SECOND_TO_NANOSECONDS - nanos;
+    seconds++;
+  }
+  return [seconds, nanos];
+}
+
+function createResource(
+  resource = {},
+  startTime: HrTime,
+  addToStart: number
+): PerformanceResourceTiming {
+  const fetchStart = core.hrTimeToNanoseconds(startTime) + 1;
+  const responseEnd = fetchStart + addToStart;
+  const milion = 1000 * 1000; // used to convert nano to milli
+  const defaultResource = {
+    connectEnd: 0,
+    connectStart: 0,
+    decodedBodySize: 0,
+    domainLookupEnd: 0,
+    domainLookupStart: 0,
+    encodedBodySize: 0,
+    fetchStart: fetchStart / milion,
+    initiatorType: 'xmlhttprequest',
+    nextHopProtocol: '',
+    redirectEnd: 0,
+    redirectStart: 0,
+    requestStart: 0,
+    responseEnd: responseEnd / milion,
+    responseStart: 0,
+    secureConnectionStart: 0,
+    transferSize: 0,
+    workerStart: 0,
+    duration: 0,
+    entryType: '',
+    name: '',
+    startTime: 0,
+  };
+  return Object.assign(
+    {},
+    defaultResource,
+    resource
+  ) as PerformanceResourceTiming;
+}
+
+describe('utils', () => {
+  let sandbox: sinon.SinonSandbox;
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox();
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe('addSpanNetworkEvent', () => {
+    describe('when entries contain the performance', () => {
+      it('should add event to span', () => {
+        const addEventSpy = sinon.spy();
+        const span = ({
+          addEvent: addEventSpy,
+        } as unknown) as tracing.Span;
+        const entries = {
+          [PTN.FETCH_START]: 123,
+        } as PerformanceEntries;
+
+        assert.strictEqual(addEventSpy.callCount, 0);
+
+        addSpanNetworkEvent(span, PTN.FETCH_START, entries);
+
+        assert.strictEqual(addEventSpy.callCount, 1);
+        const args = addEventSpy.args[0];
+
+        assert.strictEqual(args[0], 'fetchStart');
+        assert.strictEqual(args[1], 123);
+      });
+    });
+    describe('when entry has time equal to 0', () => {
+      it('should NOT add event to span', () => {
+        const addEventSpy = sinon.spy();
+        const span = ({
+          addEvent: addEventSpy,
+        } as unknown) as tracing.Span;
+        const entries = {
+          [PTN.FETCH_START]: 0,
+        } as PerformanceEntries;
+
+        assert.strictEqual(addEventSpy.callCount, 0);
+
+        addSpanNetworkEvent(span, PTN.FETCH_START, entries);
+
+        assert.strictEqual(addEventSpy.callCount, 0);
+      });
+    });
+    describe('when entries does NOT contain the performance', () => {
+      it('should NOT add event to span', () => {
+        const addEventSpy = sinon.spy();
+        const span = ({
+          addEvent: addEventSpy,
+        } as unknown) as tracing.Span;
+        const entries = {
+          [PTN.FETCH_START]: 123,
+        } as PerformanceEntries;
+
+        assert.strictEqual(addEventSpy.callCount, 0);
+
+        addSpanNetworkEvent(span, 'foo', entries);
+
+        assert.strictEqual(
+          addEventSpy.callCount,
+          0,
+          'should not call addEvent'
+        );
+      });
+    });
+  });
+  describe('getResource', () => {
+    const startTime = [0, 123123123] as HrTime;
+    let spyHrTime: any;
+    beforeEach(() => {
+      const time = createHrTime(startTime, 500);
+      sandbox.stub(performance, 'timeOrigin').value(0);
+      sandbox
+        .stub(performance, 'now')
+        .callsFake(() => hrTimeToNanoseconds(time));
+
+      spyHrTime = sinon.stub(core, 'hrTime').returns(time);
+    });
+    afterEach(() => {
+      spyHrTime.restore();
+    });
+
+    describe('when resources are empty', () => {
+      it('should return undefined', () => {
+        const spanStartTime = createHrTime(startTime, 1);
+        const spanEndTime = createHrTime(startTime, 100);
+        const spanUrl = 'http://foo.com/bar.json';
+        const resources: PerformanceResourceTiming[] = [];
+
+        const resource = getResource(
+          spanUrl,
+          spanStartTime,
+          spanEndTime,
+          resources
+        );
+
+        assert.deepStrictEqual(
+          resource.mainRequest,
+          undefined,
+          'main request should be undefined'
+        );
+      });
+    });
+
+    describe('when resources has correct entry', () => {
+      it('should return the closest one', () => {
+        const spanStartTime = createHrTime(startTime, 1);
+        const spanEndTime = createHrTime(startTime, 402);
+        const spanUrl = 'http://foo.com/bar.json';
+        const resources: PerformanceResourceTiming[] = [];
+
+        // this one started earlier
+        resources.push(
+          createResource(
+            {
+              name: 'http://foo.com/bar.json',
+            },
+            createHrTime(startTime, -1),
+            100
+          )
+        );
+
+        // this one is correct
+        resources.push(
+          createResource(
+            {
+              name: 'http://foo.com/bar.json',
+            },
+            createHrTime(startTime, 1),
+            400
+          )
+        );
+
+        // this one finished after span
+        resources.push(
+          createResource(
+            {
+              name: 'http://foo.com/bar.json',
+            },
+            createHrTime(startTime, 1),
+            1000
+          )
+        );
+
+        const resource = getResource(
+          spanUrl,
+          spanStartTime,
+          spanEndTime,
+          resources
+        );
+
+        assert.deepStrictEqual(
+          resource.mainRequest,
+          resources[1],
+          'main request should be defined'
+        );
+      });
+      describe('But one resource has been already used', () => {
+        it('should return the next closest', () => {
+          const spanStartTime = createHrTime(startTime, 1);
+          const spanEndTime = createHrTime(startTime, 402);
+          const spanUrl = 'http://foo.com/bar.json';
+          const resources: PerformanceResourceTiming[] = [];
+
+          // this one started earlier
+          resources.push(
+            createResource(
+              {
+                name: 'http://foo.com/bar.json',
+              },
+              createHrTime(startTime, -1),
+              100
+            )
+          );
+
+          // this one is correct but ignored
+          resources.push(
+            createResource(
+              {
+                name: 'http://foo.com/bar.json',
+              },
+              createHrTime(startTime, 1),
+              400
+            )
+          );
+
+          // this one is also correct
+          resources.push(
+            createResource(
+              {
+                name: 'http://foo.com/bar.json',
+              },
+              createHrTime(startTime, 1),
+              300
+            )
+          );
+
+          // this one finished after span
+          resources.push(
+            createResource(
+              {
+                name: 'http://foo.com/bar.json',
+              },
+              createHrTime(startTime, 1),
+              1000
+            )
+          );
+
+          const ignoredResources = new WeakSet<PerformanceResourceTiming>();
+          ignoredResources.add(resources[1]);
+          const resource = getResource(
+            spanUrl,
+            spanStartTime,
+            spanEndTime,
+            resources,
+            ignoredResources
+          );
+
+          assert.deepStrictEqual(
+            resource.mainRequest,
+            resources[2],
+            'main request should be defined'
+          );
+        });
+      });
+    });
+
+    describe('when there are multiple resources from CorsPreflight requests', () => {
+      it('should return main request and cors preflight request', () => {
+        const spanStartTime = createHrTime(startTime, 1);
+        const spanEndTime = createHrTime(startTime, 182);
+        const spanUrl = 'http://foo.com/bar.json';
+        const resources: PerformanceResourceTiming[] = [];
+
+        // this one started earlier
+        resources.push(
+          createResource(
+            {
+              name: 'http://foo.com/bar.json',
+            },
+            createHrTime(startTime, 1),
+            10
+          )
+        );
+
+        // this one is correct
+        resources.push(
+          createResource(
+            {
+              name: 'http://foo.com/bar.json',
+            },
+            createHrTime(startTime, 1),
+            11
+          )
+        );
+
+        // this one finished after span
+        resources.push(
+          createResource(
+            {
+              name: 'http://foo.com/bar.json',
+            },
+            createHrTime(startTime, 50),
+            100
+          )
+        );
+
+        // this one finished after span
+        resources.push(
+          createResource(
+            {
+              name: 'http://foo.com/bar.json',
+            },
+            createHrTime(startTime, 50),
+            130
+          )
+        );
+
+        const resource = getResource(
+          spanUrl,
+          spanStartTime,
+          spanEndTime,
+          resources,
+          undefined
+        );
+
+        assert.deepStrictEqual(
+          resource.corsPreFlightRequest,
+          resources[0],
+          'cors preflight request should be defined'
+        );
+
+        assert.deepStrictEqual(
+          resource.mainRequest,
+          resources[3],
+          'main request should be defined'
+        );
+      });
+    });
+  });
+});
