@sentry/ember 11.0.0-alpha.1 → 11.0.0-beta.0

package/{addon → src}/utils/instrumentEmberAppInstanceForPerformance.ts

@@ -1,20 +1,39 @@
 import type ApplicationInstance from '@ember/application/instance';
-import type Transition from '@ember/routing/-private/transition';
+import type Transition from '@ember/routing/transition';
 import type RouterService from '@ember/routing/router-service';
 import type {
   startBrowserTracingNavigationSpan as startBrowserTracingNavigationSpanType,
   startBrowserTracingPageLoadSpan as startBrowserTracingPageLoadSpanType,
 } from '@sentry/browser';
+import { getAbsoluteUrl, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, startInactiveSpan, WINDOW } from '@sentry/browser';
 import {
-  getAbsoluteUrl,
-  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
-  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
-  startInactiveSpan,
-} from '@sentry/browser';
-import type { Client, Span } from '@sentry/core';
-import type { EmberRouterMain } from '../types';
-import { getBackburner } from './performance';
-import { SENTRY_OP, URL_FULL, URL_PATH, URL_TEMPLATE } from '@sentry/conventions/attributes';
+  SENTRY_SEGMENT_NAME_SOURCE,
+  SENTRY_OP,
+  URL_FULL,
+  URL_PATH,
+  URL_TEMPLATE,
+} from '@sentry/conventions/attributes';
+import { ROUTER } from '@sentry/conventions/op';
+import {
+  filterCollectedUrl,
+  getCurrentScope,
+  hasSpanStreamingEnabled,
+  PAGELOAD_SPAN_NAME_FALLBACK,
+  ROUTER_SPAN_NAME_FALLBACK,
+  spanToJSON,
+  type Client,
+  type Span,
+} from '@sentry/core';
+import { getBackburner } from './utils.ts';
+
+interface EmberRouterMain {
+  location: {
+    formatURL?: (url: string) => string;
+    getURL?: () => string;
+    implementation?: string;
+    rootURL: string;
+  };
+}
 
 type TransitionWithIntent = Transition & { intent?: { url?: string } };
 
@@ -25,36 +44,159 @@ export function instrumentEmberAppInstanceForPerformance(
   startBrowserTracingPageLoadSpan: typeof startBrowserTracingPageLoadSpanType,
   startBrowserTracingNavigationSpan: typeof startBrowserTracingNavigationSpanType,
 ): void {
-  // eslint-disable-next-line ember/no-private-routing-service
-  const routerMain = appInstance.lookup('router:main') as EmberRouterMain;
-  let routerService = appInstance.lookup('service:router') as RouterService & {
+  const { disableRunloopPerformance, instrumentPageLoad, instrumentNavigation } = config;
+  const routerService = getRouterService(appInstance);
+
+  if (!routerService.recognize) {
+    // Router is missing critical functionality to limit cardinality of the transaction names.
+    return;
+  }
+
+  const routerMain = getRouterMain(appInstance);
+  const location = routerMain.location;
+  let activeRootSpan: Span | undefined;
+  let transitionSpan: Span | undefined;
+
+  const url = _getLocationURL(location);
+
+  if (instrumentPageLoad !== false) {
+    // Somehow the router service etc. may not be fully ready/initialized yet at this point
+    // Probably because we are running this before the Ember setup is necessarily completed
+    // So in order to accomodate this, we fall back to starting the pageload span with the current URL and update it later
+    const routeInfo = url ? routerService.recognize(url) : undefined;
+
+    activeRootSpan = startBrowserTracingPageLoadSpan(client, {
+      // With span streaming, span names have to be low cardinality, so we can't fall back to the URL.
+      name: routeInfo
+        ? `route:${routeInfo.name}`
+        : hasSpanStreamingEnabled(client)
+          ? PAGELOAD_SPAN_NAME_FALLBACK
+          : url || WINDOW.location.pathname,
+      attributes: {
+        [SENTRY_SEGMENT_NAME_SOURCE]: routeInfo ? 'route' : 'url',
+        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.pageload.ember',
+        ...(url ? _getRouteUrlAttributes(client, url, routeInfo?.params) : {}),
+        toRoute: routeInfo?.name,
+      },
+    });
+  }
+
+  const finishActiveTransaction = (_: unknown, nextInstance: unknown): void => {
+    if (nextInstance) {
+      return;
+    }
+    activeRootSpan?.end();
+    getBackburner().off('end', finishActiveTransaction);
+  };
+
+  routerService.on('routeWillChange', (transition: Transition) => {
+    const { fromRoute, toRoute } = getTransitionInformation(transition, routerService);
+
+    // Store this here to be used, even if the active span has ended
+    getCurrentScope().setTransactionName(`route:${toRoute}`);
+
+    // We want to ignore loading && error routes
+    if (transitionIsIntermediate(transition)) {
+      return;
+    }
+
+    // If this is not the initial transition, we want to end the active root span and start a new one
+    if (fromRoute != null) {
+      activeRootSpan?.end();
+
+      if (instrumentNavigation !== false) {
+        // Only `intent.url` reliably reflects the *destination* URL at `routeWillChange` time. The
+        // router's location still points at the current (pre-transition) route here, so falling back to
+        // it would tag the navigation span with the previous route's `url.*` attributes. When we don't
+        // have a trustworthy target URL, we omit them and let `routeDidChange` set them from `currentURL`.
+        const targetUrl = (transition as TransitionWithIntent).intent?.url;
+        const urlAttributes = targetUrl ? _getRouteUrlAttributes(client, targetUrl, transition.to?.params) : {};
+
+        activeRootSpan = startBrowserTracingNavigationSpan(client, {
+          name: `route:${toRoute}`,
+          attributes: {
+            [SENTRY_SEGMENT_NAME_SOURCE]: 'route',
+            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.navigation.ember',
+            ...urlAttributes,
+            fromRoute,
+            toRoute,
+          },
+        });
+      }
+    } else if (activeRootSpan && spanToJSON(activeRootSpan).attributes[SENTRY_SEGMENT_NAME_SOURCE] === 'url') {
+      // We make sure to update the pageload span with the current URL, if we couldn't get it before
+      // In this case we re-load the router:main reference, as this may change and we may have a stale reference
+      const location = getRouterMain(appInstance).location;
+      const url = _getLocationURL(location);
+      if (url) {
+        const routeInfo = routerService.recognize(url);
+        activeRootSpan.updateName(`route:${toRoute}`);
+        activeRootSpan.setAttributes({
+          [SENTRY_SEGMENT_NAME_SOURCE]: 'route',
+          ..._getRouteUrlAttributes(client, url, routeInfo?.params),
+          toRoute: toRoute,
+        });
+      }
+    }
+
+    // transition spans are only emitted if instrumentNavigation is true
+    if (instrumentNavigation === false) {
+      return;
+    }
+
+    transitionSpan = startInactiveSpan({
+      attributes: {
+        [SENTRY_OP]: ROUTER,
+        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.ember',
+      },
+      // With span streaming, span names have to be low cardinality, and Ember gives us no route
+      // template for the transition itself, so it's the fallback.
+      name: hasSpanStreamingEnabled(client) ? ROUTER_SPAN_NAME_FALLBACK : `route:${fromRoute} -> route:${toRoute}`,
+      onlyIfParent: true,
+    });
+  });
+
+  routerService.on('routeDidChange', transition => {
+    if (!transitionSpan || !activeRootSpan || transitionIsIntermediate(transition)) {
+      return;
+    }
+    transitionSpan.end();
+
+    const url = routerService.currentURL ?? _getLocationURL(location);
+    if (url) {
+      const routeInfo = routerService.recognize(url);
+      // `currentURL` is the normalized route path and never includes the hash fragment, so we source
+      // `url.full` from the location URL (which preserves `#/...` for hash-location apps) when available.
+      const fullUrl = _getLocationURL(location) || url;
+      activeRootSpan.setAttributes(
+        _getRouteUrlAttributes(client, url, routeInfo?.params ?? transition.to?.params, fullUrl),
+      );
+    }
+
+    if (disableRunloopPerformance) {
+      activeRootSpan.end();
+      return;
+    }
+
+    getBackburner().on('end', finishActiveTransaction);
+  });
+}
+
+function getRouterService(appInstance: ApplicationInstance): RouterService {
+  const routerService = appInstance.lookup('service:router') as RouterService & {
     externalRouter?: RouterService;
-    _hasMountedSentryPerformanceRouting?: boolean;
-    currentURL?: string;
   };
 
   if (routerService.externalRouter) {
     // Using ember-engines-router-service in an engine.
-    routerService = routerService.externalRouter;
-  }
-  if (routerService._hasMountedSentryPerformanceRouting) {
-    // Routing listens to route changes on the main router, and should not be initialized multiple times per page.
-    return;
-  }
-  if (!routerService.recognize) {
-    // Router is missing critical functionality to limit cardinality of the transaction names.
-    return;
+    return routerService.externalRouter;
   }
 
-  routerService._hasMountedSentryPerformanceRouting = true;
-  _instrumentEmberRouter(
-    client,
-    routerService,
-    routerMain,
-    config,
-    startBrowserTracingPageLoadSpan,
-    startBrowserTracingNavigationSpan,
-  );
+  return routerService;
+}
+
+function getRouterMain(appInstance: ApplicationInstance): EmberRouterMain {
+  return appInstance.lookup('router:main') as EmberRouterMain;
 }
 
 function getTransitionInformation(
@@ -62,7 +204,8 @@ function getTransitionInformation(
   router: RouterService,
 ): { fromRoute?: string; toRoute?: string } {
   const fromRoute = transition?.from?.name;
-  const toRoute = transition?.to?.name || router.currentRouteName;
+  const toRoute = transition?.to?.name ?? router.currentRouteName ?? undefined;
+
   return {
     fromRoute,
     toRoute,
@@ -98,8 +241,8 @@ function buildUrlTemplate(path: string, params: Record<string, unknown> = {}): s
   return template;
 }
 
-// Only exported for testing
-export function _getRouteUrlAttributes(
+function _getRouteUrlAttributes(
+  client: Client,
   url: string,
   params: Record<string, unknown> = {},
   fullUrl: string = url,
@@ -110,7 +253,7 @@ export function _getRouteUrlAttributes(
   // fragment (e.g. `https://host/#/tracing`), which would otherwise be lost by `getUrlPathFromEmberLocation`.
   return {
     [URL_PATH]: path,
-    [URL_FULL]: getAbsoluteUrl(fullUrl),
+    [URL_FULL]: filterCollectedUrl(getAbsoluteUrl(fullUrl), client),
     [URL_TEMPLATE]: buildUrlTemplate(path, params),
   };
 }
@@ -129,110 +272,6 @@ export function _getLocationURL(location: EmberRouterMain['location']): string {
   return url;
 }
 
-function _instrumentEmberRouter(
-  client: Client,
-  routerService: RouterService & { currentURL?: string },
-  routerMain: EmberRouterMain,
-  config: { disableRunloopPerformance?: boolean; instrumentPageLoad?: boolean; instrumentNavigation?: boolean },
-  startBrowserTracingPageLoadSpan: typeof startBrowserTracingPageLoadSpanType,
-  startBrowserTracingNavigationSpan: typeof startBrowserTracingNavigationSpanType,
-): void {
-  const { disableRunloopPerformance, instrumentPageLoad, instrumentNavigation } = config;
-  const location = routerMain.location;
-  let activeRootSpan: Span | undefined;
-  let transitionSpan: Span | undefined;
-
-  const url = _getLocationURL(location);
-
-  if (url && instrumentPageLoad !== false) {
-    const routeInfo = routerService.recognize(url);
-    activeRootSpan = startBrowserTracingPageLoadSpan(client, {
-      name: `route:${routeInfo.name}`,
-      attributes: {
-        [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
-        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.pageload.ember',
-        ..._getRouteUrlAttributes(url, routeInfo.params),
-        url,
-        toRoute: routeInfo.name,
-      },
-    });
-  }
-
-  const finishActiveTransaction = (_: unknown, nextInstance: unknown): void => {
-    if (nextInstance) {
-      return;
-    }
-    activeRootSpan?.end();
-    getBackburner().off('end', finishActiveTransaction);
-  };
-
-  if (instrumentNavigation === false) {
-    return;
-  }
-
-  routerService.on('routeWillChange', (transition: Transition) => {
-    const { fromRoute, toRoute } = getTransitionInformation(transition, routerService);
-
-    // We want to ignore loading && error routes
-    if (transitionIsIntermediate(transition)) {
-      return;
-    }
-
-    activeRootSpan?.end();
-
-    // Only `intent.url` reliably reflects the *destination* URL at `routeWillChange` time. The
-    // router's location still points at the current (pre-transition) route here, so falling back to
-    // it would tag the navigation span with the previous route's `url.*` attributes. When we don't
-    // have a trustworthy target URL, we omit them and let `routeDidChange` set them from `currentURL`.
-    const targetUrl = (transition as TransitionWithIntent).intent?.url;
-    const urlAttributes = targetUrl ? _getRouteUrlAttributes(targetUrl, transition.to?.params) : {};
-
-    activeRootSpan = startBrowserTracingNavigationSpan(client, {
-      name: `route:${toRoute}`,
-      attributes: {
-        [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
-        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.navigation.ember',
-        ...urlAttributes,
-        fromRoute,
-        toRoute,
-      },
-    });
-
-    transitionSpan = startInactiveSpan({
-      attributes: {
-        // TODO(conventions): Replace `'router'` with the `router` span op constant once it is released in `@sentry/conventions`.
-        [SENTRY_OP]: 'router',
-        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.ember',
-      },
-      name: `route:${fromRoute} -> route:${toRoute}`,
-      onlyIfParent: true,
-    });
-  });
-
-  routerService.on('routeDidChange', transition => {
-    if (!transitionSpan || !activeRootSpan || transitionIsIntermediate(transition)) {
-      return;
-    }
-    transitionSpan.end();
-
-    const url = routerService.currentURL ?? _getLocationURL(location);
-    if (url) {
-      const routeInfo = routerService.recognize(url);
-      // `currentURL` is the normalized route path and never includes the hash fragment, so we source
-      // `url.full` from the location URL (which preserves `#/...` for hash-location apps) when available.
-      const fullUrl = _getLocationURL(location) || url;
-      activeRootSpan.setAttributes(_getRouteUrlAttributes(url, routeInfo.params ?? transition.to?.params, fullUrl));
-    }
-
-    if (disableRunloopPerformance) {
-      activeRootSpan.end();
-      return;
-    }
-
-    getBackburner().on('end', finishActiveTransaction);
-  });
-}
-
 function transitionIsIntermediate(transition: Transition): boolean {
   //  We want to use ignore, as this may actually be defined on new versions
   // eslint-disable-next-line @typescript-eslint/ban-ts-comment

package/{addon → src}/utils/instrumentEmberGlobals.ts

@@ -1,12 +1,14 @@
 import { subscribe } from '@ember/instrumentation';
 import { scheduleOnce } from '@ember/runloop';
-import type { EmberRunQueues } from '@ember/runloop/-private/types';
 import { SENTRY_OP, UI_COMPONENT_NAME } from '@sentry/conventions/attributes';
-import { BROWSER_UI_RENDER_SPAN_OP, BROWSER_UI_TASK_SPAN_OP, GENERAL_FUNCTION_SPAN_OP } from '@sentry/conventions/op';
+import { UI_MOUNT, UI_RENDER, UI_TASK, FUNCTION } from '@sentry/conventions/op';
 import { getActiveSpan, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, startInactiveSpan } from '@sentry/browser';
 import type { Span } from '@sentry/core';
 import { browserPerformanceTimeOrigin, timestampInSeconds } from '@sentry/core';
-import { getBackburner } from './performance';
+import { getBackburner } from './utils.ts';
+
+// Ember runloop queue names
+type EmberRunQueues = 'actions' | 'afterRender' | 'destroy' | 'render' | 'routerTransitions' | 'sync';
 
 type Payload = {
   containerKey: string;
@@ -88,7 +90,7 @@ function _instrumentEmberRunloop(config: { minimumRunloopQueueDuration?: number
         if ((now - currentQueueStart) * 1000 >= minQueueDuration) {
           startInactiveSpan({
             attributes: {
-              [SENTRY_OP]: BROWSER_UI_TASK_SPAN_OP,
+              [SENTRY_OP]: UI_TASK,
               [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.ember',
               'ember.runloop.queue': queue,
             },
@@ -175,23 +177,23 @@ function _instrumentComponents(config: {
   const beforeComponentDefinitionEntries: RenderEntries = new WeakMap();
 
   function _subscribeToRenderEvents(): void {
-    subscribe('render.component', {
-      before(_name: string, _timestamp: number, payload: Payload) {
-        _processComponentRenderBefore(payload, beforeEntries);
+    subscribe<void>('render.component', {
+      before(_name: string, _timestamp: number, payload: object) {
+        _processComponentRenderBefore(payload as Payload, beforeEntries);
       },
 
-      after(_name: string, _timestamp: number, payload: Payload, _beganIndex: number) {
-        _processComponentRenderAfter(payload, beforeEntries, BROWSER_UI_RENDER_SPAN_OP, minComponentDuration);
+      after(_name: string, _timestamp: number, payload: object) {
+        _processComponentRenderAfter(payload as Payload, beforeEntries, UI_RENDER, minComponentDuration);
       },
     });
     if (enableComponentDefinitions) {
-      subscribe('render.getComponentDefinition', {
-        before(_name: string, _timestamp: number, payload: Payload) {
-          _processComponentRenderBefore(payload, beforeComponentDefinitionEntries);
+      subscribe<void>('render.getComponentDefinition', {
+        before(_name: string, _timestamp: number, payload: object) {
+          _processComponentRenderBefore(payload as Payload, beforeComponentDefinitionEntries);
         },
 
-        after(_name: string, _timestamp: number, payload: Payload, _beganIndex: number) {
-          _processComponentRenderAfter(payload, beforeComponentDefinitionEntries, GENERAL_FUNCTION_SPAN_OP, 0);
+        after(_name: string, _timestamp: number, payload: object) {
+          _processComponentRenderAfter(payload as Payload, beforeComponentDefinitionEntries, FUNCTION, 0);
         },
       });
     }
@@ -235,8 +237,7 @@ function _instrumentInitialLoad(): void {
   startInactiveSpan({
     name: 'init',
     attributes: {
-      // TODO(v11): Replace with the `ui.mount` constant from `@sentry/conventions/op` once it is registered there.
-      [SENTRY_OP]: 'ui.mount',
+      [SENTRY_OP]: UI_MOUNT,
       [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.ember',
     },
     startTime,

package/src/utils/instrumentRoutePerformance.ts

@@ -0,0 +1,79 @@
+import { startSpan } from '@sentry/browser';
+import { CODE_FUNCTION_NAME, SENTRY_OP } from '@sentry/conventions/attributes';
+import { FUNCTION } from '@sentry/conventions/op';
+import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+
+import type Route from '@ember/routing/route';
+
+type RouteConstructor = new (...args: ConstructorParameters<typeof Route>) => Route;
+
+/**
+ * Enables monitoring the performance of an Ember app.
+ *
+ * This wraps the route's lifecycle hooks (beforeModel, model, afterModel, setupController)
+ * with Sentry spans to track their performance.
+ *
+ * @param BaseRoute - The Route class to instrument
+ * @returns The instrumented Route class
+ *
+ * @example
+ * ```ts
+ * import Route from '@ember/routing/route';
+ * import { instrumentRoutePerformance } from '@sentry/ember';
+ *
+ * class ApplicationRoute extends Route {
+ *   async model() {
+ *     return this.store.findAll('post');
+ *   }
+ * }
+ *
+ * export default instrumentRoutePerformance(ApplicationRoute);
+ * ```
+ */
+export function instrumentRoutePerformance<T extends RouteConstructor>(BaseRoute: T): T {
+  const instrumentFunction = async (
+    hookName: string,
+    name: string,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Route hooks have varied signatures that can't be unified with unknown
+    fn: (...args: any[]) => any,
+    args: unknown[],
+  ): Promise<unknown> => {
+    return startSpan(
+      {
+        attributes: {
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.ember',
+          [SENTRY_OP]: FUNCTION,
+          [CODE_FUNCTION_NAME]: hookName,
+        },
+        name,
+        onlyIfParent: true,
+      },
+      () => {
+        return fn(...args);
+      },
+    );
+  };
+
+  const routeName = BaseRoute.name;
+
+  return {
+    // @ts-expect-error TS2545 We do not need to redefine a constructor here
+    [routeName]: class extends BaseRoute {
+      public beforeModel(...args: unknown[]): void | Promise<unknown> {
+        return instrumentFunction('beforeModel', this.fullRouteName, super.beforeModel.bind(this), args);
+      }
+
+      public async model(...args: unknown[]): Promise<unknown> {
+        return instrumentFunction('model', this.fullRouteName, super.model.bind(this), args);
+      }
+
+      public afterModel(...args: unknown[]): void | Promise<unknown> {
+        return instrumentFunction('afterModel', this.fullRouteName, super.afterModel.bind(this), args);
+      }
+
+      public setupController(...args: unknown[]): void | Promise<unknown> {
+        return instrumentFunction('setupController', this.fullRouteName, super.setupController.bind(this), args);
+      }
+    },
+  }[routeName] as T;
+}

package/src/utils/utils.ts

@@ -0,0 +1,25 @@
+import { _backburner, run } from '@ember/runloop';
+
+interface ExtendedBackburner {
+  on(eventName: string, callback: (...args: unknown[]) => void): void;
+  off(eventName: string, callback: (...args: unknown[]) => void): void;
+}
+
+export function getBackburner(): Pick<ExtendedBackburner, 'on' | 'off'> {
+  if (_backburner) {
+    return _backburner;
+  }
+
+  if ((run as unknown as { backburner?: Pick<ExtendedBackburner, 'on' | 'off'> }).backburner) {
+    return (run as unknown as { backburner: Pick<ExtendedBackburner, 'on' | 'off'> }).backburner;
+  }
+
+  return {
+    on() {
+      // noop
+    },
+    off() {
+      // noop
+    },
+  };
+}

package/.oxlintrc.json

@@ -1,13 +0,0 @@
-{
-  "$schema": "../../node_modules/oxlint/configuration_schema.json",
-  "extends": ["../../.oxlintrc.base.json"],
-  "overrides": [
-    {
-      "files": ["vendor/**/*.js"],
-      "env": {
-        "browser": true,
-        "node": false
-      }
-    }
-  ]
-}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2020 Functional Software, Inc. dba Sentry
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.