@pagerduty/backstage-plugin-entity-processor 0.3.2 → 0.3.4

package/dist/index.cjs.js

@@ -2,680 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var backendPluginApi = require('@backstage/backend-plugin-api');
-var alpha = require('@backstage/plugin-catalog-node/alpha');
-var catalogModel = require('@backstage/catalog-model');
-var pluginCatalogNode = require('@backstage/plugin-catalog-node');
-var fetch = require('node-fetch');
+var module$1 = require('./module.cjs.js');
 
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
-var fetch__default = /*#__PURE__*/_interopDefaultCompat(fetch);
 
-class PagerDutyClient {
-  discovery;
-  logger;
-  baseUrl = "";
-  constructor({ discovery, logger }) {
-    this.discovery = discovery;
-    this.logger = logger;
-  }
-  async addServiceRelationToService(serviceId, relations) {
-    let response;
-    if (this.baseUrl === "") {
-      this.baseUrl = await this.discovery.getBaseUrl("pagerduty");
-    }
-    const options = {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json; charset=UTF-8",
-        Accept: "application/json, text/plain, */*"
-      },
-      body: JSON.stringify(relations)
-    };
-    const url = `${await this.discovery.getBaseUrl(
-      "pagerduty"
-    )}/dependencies/service/${serviceId}`;
-    try {
-      response = await fetchWithRetries(url, options);
-      if (response.status >= 500) {
-        throw new Error(`Failed to add service relation to service ${serviceId}. PagerDuty API returned a server error. Retrying with the same arguments will not work.`);
-      }
-      if (!response.ok) {
-        throw new Error(await response.text());
-      }
-    } catch (error) {
-      this.logger.error(`Failed to add dependencies: ${error}`);
-      throw new Error(`Failed to add dependencies: ${error}`);
-    }
-  }
-  async removeServiceRelationFromService(serviceId, relations) {
-    let response;
-    if (this.baseUrl === "") {
-      this.baseUrl = await this.discovery.getBaseUrl("pagerduty");
-    }
-    const options = {
-      method: "DELETE",
-      headers: {
-        "Content-Type": "application/json; charset=UTF-8",
-        Accept: "application/json, text/plain, */*"
-      },
-      body: JSON.stringify(relations)
-    };
-    const url = `${await this.discovery.getBaseUrl(
-      "pagerduty"
-    )}/dependencies/service/${serviceId}`;
-    try {
-      response = await fetchWithRetries(url, options);
-      if (response.status >= 500) {
-        throw new Error(`Failed to remove service relation from service ${serviceId}. PagerDuty API returned a server error. Retrying with the same arguments will not work.`);
-      }
-      if (response.status === 404) {
-        throw new Error(`Service ${serviceId} or dependencies not found.`);
-      }
-      if (!response.ok) {
-        throw new Error(await response.text());
-      }
-    } catch (error) {
-      this.logger.error(`Failed to remove dependencies from ${serviceId}: ${error}`);
-      throw new Error(`Failed to remove dependencies from ${serviceId}: ${error}`);
-    }
-  }
-  async getAllServiceMappings() {
-    let response;
-    const mappings = {};
-    if (this.baseUrl === "") {
-      this.baseUrl = await this.discovery.getBaseUrl("pagerduty");
-    }
-    const options = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json; charset=UTF-8",
-        Accept: "application/json, text/plain, */*"
-      }
-    };
-    const url = `${await this.discovery.getBaseUrl(
-      "pagerduty"
-    )}/mapping/entity`;
-    try {
-      response = await fetchWithRetries(url, options);
-      if (response.status >= 500) {
-        throw new Error(`Failed to get all service mappings. API returned a server error. Retrying with the same arguments will not work.`);
-      }
-      const foundMappings = await response.json();
-      switch (response.status) {
-        case 400:
-          throw new Error(await response.text());
-        case 404:
-          return mappings;
-        default:
-          foundMappings.mappings.forEach((mapping) => {
-            mappings[mapping.serviceId] = mapping.entityRef;
-          });
-          return mappings;
-      }
-    } catch (error) {
-      this.logger.error(`Failed to retrieve mappings: ${error}`);
-      throw new Error(`Failed to retrieve mappings: ${error}`);
-    }
-  }
-  async findServiceMapping({ type, namespace, name }) {
-    let response;
-    if (this.baseUrl === "") {
-      this.baseUrl = await this.discovery.getBaseUrl("pagerduty");
-    }
-    const options = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json; charset=UTF-8",
-        Accept: "application/json, text/plain, */*"
-      }
-    };
-    const url = `${await this.discovery.getBaseUrl(
-      "pagerduty"
-    )}/mapping/entity/${type}/${namespace}/${name}`;
-    try {
-      response = await fetchWithRetries(url, options);
-      if (response.status >= 500) {
-        throw new Error(`Failed to find service mapping. API returned a server error. Retrying with the same arguments will not work.`);
-      }
-      const foundMapping = await response.json();
-      switch (response.status) {
-        case 400:
-          throw new Error(await response.text());
-        case 404:
-          return void 0;
-        default:
-          this.logger.debug(`Found mapping for ${type}:${namespace}/${name}: ${JSON.stringify(foundMapping.mapping)}`);
-          return {
-            serviceId: foundMapping.mapping.serviceId,
-            integrationKey: foundMapping.mapping.integrationKey,
-            entityRef: foundMapping.mapping.entityRef,
-            account: foundMapping.mapping.account
-          };
-      }
-    } catch (error) {
-      this.logger.error(`Failed to retrieve mapping for ${type}:${namespace}/${name}: ${error}`);
-      throw new Error(`Failed to retrieve mapping for ${type}:${namespace}/${name}: ${error}`);
-    }
-  }
-  async findServiceMappingById(serviceId) {
-    let response;
-    if (this.baseUrl === "") {
-      this.baseUrl = await this.discovery.getBaseUrl("pagerduty");
-    }
-    const options = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json; charset=UTF-8",
-        Accept: "application/json, text/plain, */*"
-      }
-    };
-    const url = `${await this.discovery.getBaseUrl(
-      "pagerduty"
-    )}/mapping/entity/service/${serviceId}`;
-    try {
-      response = await fetchWithRetries(url, options);
-      if (response.status >= 500) {
-        throw new Error(`Failed to find service mapping by id. API returned a server error. Retrying with the same arguments will not work.`);
-      }
-      const foundMapping = await response.json();
-      switch (response.status) {
-        case 400:
-          throw new Error(await response.text());
-        case 404:
-          return void 0;
-        default:
-          this.logger.debug(`Found mapping for serviceId ${serviceId}: ${JSON.stringify(foundMapping.mapping)}`);
-          return {
-            serviceId: foundMapping.mapping.serviceId,
-            integrationKey: foundMapping.mapping.integrationKey,
-            entityRef: foundMapping.mapping.entityRef,
-            account: foundMapping.mapping.account
-          };
-      }
-    } catch (error) {
-      this.logger.error(`Failed to retrieve mapping for serviceId ${serviceId}: ${error}`);
-      throw new Error(`Failed to retrieve mapping for serviceId ${serviceId}: ${error}`);
-    }
-  }
-  async insertServiceMapping(mapping) {
-    let response;
-    if (this.baseUrl === "") {
-      this.baseUrl = await this.discovery.getBaseUrl("pagerduty");
-    }
-    const options = {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json; charset=UTF-8",
-        Accept: "application/json, text/plain, */*"
-      },
-      body: JSON.stringify(mapping)
-    };
-    const url = `${await this.discovery.getBaseUrl(
-      "pagerduty"
-    )}/mapping/entity`;
-    try {
-      response = await fetchWithRetries(url, options);
-      if (response.status >= 500) {
-        throw new Error(`Failed to add service mapping. API returned a server error. Retrying with the same arguments will not work.`);
-      }
-      if (!response.ok) {
-        throw new Error(await response.text());
-      }
-    } catch (error) {
-      this.logger.error(`Failed to add mapping for ${mapping.entityRef}: ${error}`);
-      throw new Error(`Failed to add mapping for ${mapping.entityRef}: ${error}`);
-    }
-  }
-  async getServiceDependencies(serviceId, account) {
-    let response;
-    if (this.baseUrl === "") {
-      this.baseUrl = await this.discovery.getBaseUrl("pagerduty");
-    }
-    const options = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json; charset=UTF-8",
-        Accept: "application/json, text/plain, */*"
-      }
-    };
-    let url = `${await this.discovery.getBaseUrl(
-      "pagerduty"
-    )}/dependencies/service/${serviceId}`;
-    if (account) {
-      url = url.concat(`?account=${account}`);
-    }
-    try {
-      response = await fetchWithRetries(url, options);
-      if (response.status >= 500) {
-        throw new Error(`Failed to get service depedencies. PagerDuty API returned a server error. Retrying with the same arguments will not work.`);
-      }
-      const foundDependencies = await response.json();
-      switch (response.status) {
-        case 400:
-          throw new Error(await response.text());
-        case 404:
-          return [];
-        default:
-          return foundDependencies.relationships;
-      }
-    } catch (error) {
-      this.logger.error(`Failed to retrieve mapping for ${serviceId}: ${error}`);
-      throw new Error(`Failed to retrieve mapping for ${serviceId}: ${error}`);
-    }
-  }
-  async getServiceIdAnnotationFromCatalog(entityRef) {
-    let response;
-    if (this.baseUrl === "") {
-      this.baseUrl = await this.discovery.getBaseUrl("pagerduty");
-    }
-    const options = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json; charset=UTF-8",
-        Accept: "application/json, text/plain, */*"
-      }
-    };
-    const [type, rest] = entityRef.split(":");
-    const [namespace, name] = rest.split("/");
-    const url = `${await this.discovery.getBaseUrl(
-      "pagerduty"
-    )}/catalog/entity/${type}/${namespace}/${name}`;
-    try {
-      response = await fetchWithRetries(url, options);
-      if (response.status >= 500) {
-        throw new Error(`Failed to get service id annotation from catalog. API returned a server error. Retrying with the same arguments will not work.`);
-      }
-      const foundServiceId = await response.json();
-      switch (response.status) {
-        case 400:
-          throw new Error(await response.text());
-        case 404:
-          return "";
-        default:
-          return foundServiceId;
-      }
-    } catch (error) {
-      this.logger.error(`Failed to retrieve a PagerDuty service id for ${entityRef}: ${error}`);
-      throw new Error(`Failed to retrieve a PagerDuty service id for ${entityRef}: ${error}`);
-    }
-  }
-  async getServiceIdFromIntegrationKey(integrationKey, account) {
-    let response;
-    if (this.baseUrl === "") {
-      this.baseUrl = await this.discovery.getBaseUrl("pagerduty");
-    }
-    const options = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json; charset=UTF-8",
-        Accept: "application/json, text/plain, */*"
-      }
-    };
-    let url = `${await this.discovery.getBaseUrl(
-      "pagerduty"
-    )}/services?integration_key=${integrationKey}`;
-    if (account) {
-      url = url.concat(`&account=${account}`);
-    }
-    try {
-      response = await fetchWithRetries(url, options);
-      if (response.status >= 500) {
-        throw new Error(`Failed to get service id from integration key ${integrationKey}. PagerDuty API returned a server error. Retrying with the same arguments will not work.`);
-      }
-      const foundService = await response.json();
-      switch (response.status) {
-        case 400:
-          throw new Error(await response.text());
-        case 404:
-          return "";
-        default:
-          return foundService.service.id;
-      }
-    } catch (error) {
-      this.logger.error(`Failed to retrieve a PagerDuty service id for integration key ${integrationKey}: ${error}`);
-      throw new Error(`Failed to retrieve a PagerDuty service id for integration key ${integrationKey}: ${error}`);
-    }
-  }
-  async getIntegrationKeyFromServiceId(serviceId, account) {
-    let response;
-    if (this.baseUrl === "") {
-      this.baseUrl = await this.discovery.getBaseUrl("pagerduty");
-    }
-    const options = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json; charset=UTF-8",
-        Accept: "application/json, text/plain, */*"
-      }
-    };
-    let url = `${await this.discovery.getBaseUrl(
-      "pagerduty"
-    )}/services/${serviceId}`;
-    if (account) {
-      url = url.concat(`?account=${account}`);
-    }
-    try {
-      response = await fetchWithRetries(url, options);
-      if (response.status >= 500) {
-        throw new Error(`Failed to get integration key from service id ${serviceId}. PagerDuty API returned a server error. Retrying with the same arguments will not work.`);
-      }
-      const foundService = await response.json();
-      const backstageIntegration = foundService.service.integrations?.find((integration) => integration.vendor?.id === "PRO19CT");
-      switch (response.status) {
-        case 400:
-          throw new Error(await response.text());
-        case 404:
-          return "";
-        default:
-          if (!backstageIntegration) {
-            return void 0;
-          }
-          return backstageIntegration.integration_key;
-      }
-    } catch (error) {
-      this.logger.error(`No Backstage integration found for service id ${serviceId}: ${error}`);
-      throw new Error(`No Backstage integration found for service id ${serviceId}: ${error}`);
-    }
-  }
-  async getServiceDependencyStrategySetting() {
-    const SERVICE_DEPENDENCY_SYNC_STRATEGY = "settings::service-dependency-sync-strategy";
-    let response;
-    if (this.baseUrl === "") {
-      this.baseUrl = await this.discovery.getBaseUrl("pagerduty");
-    }
-    const options = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json; charset=UTF-8",
-        Accept: "application/json, text/plain, */*"
-      }
-    };
-    const url = `${await this.discovery.getBaseUrl(
-      "pagerduty"
-    )}/settings/${SERVICE_DEPENDENCY_SYNC_STRATEGY}`;
-    try {
-      response = await fetchWithRetries(url, options);
-      if (response.status >= 500) {
-        throw new Error(`Failed to get service depedency strategy. API returned a server error. Retrying with the same arguments will not work.`);
-      }
-      const setting = await response.json();
-      switch (response.status) {
-        case 400:
-          throw new Error(await response.text());
-        case 404:
-          return "disabled";
-        default:
-          return setting.value;
-      }
-    } catch (error) {
-      this.logger.error(`Error getting value for setting: ${error}`);
-      throw new Error(`Error getting value for setting: ${error}`);
-    }
-  }
-}
-async function fetchWithRetries(url, options) {
-  let response;
-  let error = new Error();
-  const maxRetries = 5;
-  const delay = 1e3;
-  let factor = 2;
-  for (let i = 0; i < maxRetries; i++) {
-    try {
-      response = await fetch__default.default(url, options);
-      return response;
-    } catch (e) {
-      error = e;
-    }
-    const timeout = delay * factor;
-    await new Promise((resolve) => setTimeout(resolve, timeout));
-    factor *= 2;
-  }
-  throw new Error(`Failed to fetch data after ${maxRetries} retries. Last error: ${error}`);
-}
-
-let client;
-class PagerDutyEntityProcessor {
-  logger;
-  discovery;
-  shouldProcessEntity = (entity) => {
-    return entity.kind === "Component";
-  };
-  constructor({ logger, discovery }) {
-    this.logger = logger;
-    this.discovery = discovery;
-    client = new PagerDutyClient({ discovery: this.discovery, logger: this.logger });
-  }
-  getProcessorName() {
-    return "PagerDutyEntityProcessor";
-  }
-  async preProcessEntity(entity) {
-    if (this.shouldProcessEntity(entity)) {
-      const strategySetting = await client.getServiceDependencyStrategySetting();
-      if (strategySetting && strategySetting === "pagerduty") {
-        if (entity.spec?.dependsOn) {
-          entity.spec.dependsOn = [];
-        }
-      }
-    }
-    return entity;
-  }
-  async postProcessEntity(entity, _location, emit) {
-    if (this.shouldProcessEntity(entity)) {
-      try {
-        const mapping = await client.findServiceMapping({
-          type: entity.kind.toLowerCase(),
-          namespace: entity.metadata.namespace.toLowerCase(),
-          name: entity.metadata.name.toLowerCase()
-        });
-        if (mapping) {
-          updateAnnotations(
-            entity,
-            {
-              serviceId: mapping.serviceId,
-              integrationKey: mapping.integrationKey,
-              account: mapping.account
-            }
-          );
-          this.logger.debug(`Added annotations to entity ${entity.metadata.name} with service id: ${mapping.serviceId}, integration key: ${mapping.integrationKey} and account: ${mapping.account}`);
-        } else {
-          this.logger.debug(`No mapping found for entity: ${entity.metadata.name}. Adding annotations to the database.`);
-          let serviceId2 = entity.metadata.annotations?.["pagerduty.com/service-id"];
-          let integrationKey = entity.metadata.annotations?.["pagerduty.com/integration-key"];
-          const account = entity.metadata.annotations?.["pagerduty.com/account"];
-          const entityRef = `${entity.kind.toLowerCase()}:${entity.metadata.namespace?.toLowerCase()}/${entity.metadata.name.toLowerCase()}`;
-          if (serviceId2) {
-            const serviceMappingOverrideFound = await client.findServiceMappingById(serviceId2);
-            if (!serviceMappingOverrideFound) {
-              if (!integrationKey) {
-                const foundIntegrationKey = await client.getIntegrationKeyFromServiceId(serviceId2, account);
-                if (foundIntegrationKey) {
-                  integrationKey = foundIntegrationKey;
-                }
-              }
-              this.logger.debug(`Inserting mapping for entity: ${entityRef} with service id: ${serviceId2}, integration key: ${integrationKey} and account: ${account}`);
-              await client.insertServiceMapping({
-                entityRef,
-                serviceId: serviceId2,
-                integrationKey,
-                account
-              });
-              updateAnnotations(
-                entity,
-                {
-                  serviceId: serviceId2,
-                  integrationKey,
-                  account
-                }
-              );
-            } else {
-              this.logger.debug(`Service mapping override found for service id: ${serviceId2}.`);
-              updateAnnotations(entity, {});
-            }
-          } else if (integrationKey) {
-            serviceId2 = await client.getServiceIdFromIntegrationKey(integrationKey, account);
-            const serviceMappingOverrideFound = await client.findServiceMappingById(serviceId2);
-            if (!serviceMappingOverrideFound) {
-              this.logger.debug(`Inserting mapping for entity: ${entityRef} with new service id: ${serviceId2}, integration key: ${integrationKey} and account: ${account}`);
-              await client.insertServiceMapping({
-                entityRef,
-                serviceId: serviceId2,
-                integrationKey,
-                account
-              });
-              updateAnnotations(
-                entity,
-                {
-                  serviceId: serviceId2,
-                  integrationKey,
-                  account
-                }
-              );
-            } else {
-              this.logger.debug(`Service mapping override found for service id: ${serviceId2}. Skipping adding to the database.`);
-              updateAnnotations(entity, {});
-            }
-          }
-        }
-        const serviceId = entity.metadata.annotations?.["pagerduty.com/service-id"];
-        if (serviceId) {
-          const strategySetting = await client.getServiceDependencyStrategySetting();
-          if (strategySetting && strategySetting !== "disabled") {
-            let dependencyAnnotations = [];
-            if (entity.spec?.dependsOn) {
-              dependencyAnnotations = JSON.parse(JSON.stringify(entity.spec?.dependsOn));
-            }
-            const mappings = await client.getAllServiceMappings();
-            const entityDependencies = await buildExistingDependencies(dependencyAnnotations);
-            const account = entity.metadata.annotations?.["pagerduty.com/account"];
-            const dependencies = await client.getServiceDependencies(serviceId, account);
-            const filteredDependencies = dependencies.filter((x) => x.dependent_service.id === serviceId);
-            const dependencyIds = filteredDependencies.map((x) => x.supporting_service.id);
-            const dependenciesMissingInBackstage = dependencyIds.filter((x) => !entityDependencies.includes(x));
-            const dependenciesMissingInPagerDuty = entityDependencies.filter((x) => !dependencyIds.includes(x));
-            switch (strategySetting) {
-              case "backstage":
-                if (dependenciesMissingInPagerDuty.length > 0) {
-                  this.logger.debug(`Updating dependencies on PagerDuty with: ${JSON.stringify(dependenciesMissingInPagerDuty)}`);
-                  await client.addServiceRelationToService(serviceId, dependenciesMissingInPagerDuty);
-                }
-                if (dependenciesMissingInBackstage.length > 0) {
-                  this.logger.debug(`Removing dependencies on PagerDuty with: ${JSON.stringify(dependenciesMissingInBackstage)}`);
-                  await client.removeServiceRelationFromService(serviceId, dependenciesMissingInBackstage);
-                }
-                break;
-              case "pagerduty":
-                entity.spec.dependsOn = refreshServiceDependencyAnnotations(entity, mappings, dependencyIds, emit);
-                break;
-              case "both":
-                this.logger.debug(`Updating dependencies on PagerDuty with: ${JSON.stringify(dependenciesMissingInPagerDuty)} and Backstage with: ${JSON.stringify(dependenciesMissingInBackstage)}`);
-                if (dependenciesMissingInPagerDuty.length > 0) {
-                  await client.addServiceRelationToService(serviceId, dependenciesMissingInPagerDuty);
-                }
-                entity.spec.dependsOn = refreshServiceDependencyAnnotations(entity, mappings, dependencyIds, emit);
-                break;
-              default:
-                break;
-            }
-          }
-        }
-      } catch (error) {
-        this.logger.error(`Error processing entity ${entity.metadata.name}: ${error}`);
-      }
-    }
-    return entity;
-  }
-}
-function refreshServiceDependencyAnnotations(entity, mappingsDic, dependencies, emit) {
-  const dependencyList = [];
-  dependencies.forEach((dependencyId) => {
-    const foundEntityRef = mappingsDic[dependencyId];
-    if (foundEntityRef && foundEntityRef !== "") {
-      dependencyList.push(foundEntityRef);
-      const entityRefParts = foundEntityRef.split(":");
-      const kind = entityRefParts[0];
-      const namespaceName = entityRefParts[1].split("/");
-      const namespace = namespaceName[0];
-      const name = namespaceName[1];
-      emit(pluginCatalogNode.processingResult.relation({
-        source: {
-          kind: entity.kind,
-          namespace: entity.metadata.namespace,
-          name: entity.metadata.name
-        },
-        target: {
-          kind,
-          namespace,
-          name
-        },
-        type: catalogModel.RELATION_DEPENDS_ON
-      }));
-      emit(pluginCatalogNode.processingResult.relation({
-        source: {
-          kind,
-          namespace,
-          name
-        },
-        target: {
-          kind: entity.kind,
-          namespace: entity.metadata.namespace,
-          name: entity.metadata.name
-        },
-        type: catalogModel.RELATION_DEPENDENCY_OF
-      }));
-    }
-  });
-  return dependencyList;
-}
-function updateAnnotations(entity, annotations) {
-  if (annotations.serviceId && annotations.serviceId !== "") {
-    entity.metadata.annotations["pagerduty.com/service-id"] = annotations.serviceId;
-  } else {
-    delete entity.metadata.annotations["pagerduty.com/service-id"];
-  }
-  if (annotations.integrationKey && annotations.integrationKey !== "") {
-    entity.metadata.annotations["pagerduty.com/integration-key"] = annotations.integrationKey;
-  } else {
-    delete entity.metadata.annotations["pagerduty.com/integration-key"];
-  }
-  if (annotations.account && annotations.account !== "") {
-    entity.metadata.annotations["pagerduty.com/account"] = annotations.account;
-  } else {
-    delete entity.metadata.annotations["pagerduty.com/account"];
-  }
-}
-async function buildExistingDependencies(dependencyAnnotations) {
-  const dependencies = [];
-  if (dependencyAnnotations.length > 0) {
-    await Promise.all(
-      dependencyAnnotations.map(async (dependency) => {
-        const foundServiceId = await client.getServiceIdAnnotationFromCatalog(dependency);
-        if (foundServiceId !== "") {
-          dependencies.push(foundServiceId);
-        }
-      })
-    );
-  }
-  return dependencies;
-}
-
-const pagerDutyEntityProcessor = backendPluginApi.createBackendModule({
-  pluginId: "catalog",
-  moduleId: "pagerduty-entity-processor",
-  register(env) {
-    env.registerInit({
-      deps: {
-        logger: backendPluginApi.coreServices.logger,
-        catalog: alpha.catalogProcessingExtensionPoint,
-        discovery: backendPluginApi.coreServices.discovery
-      },
-      async init({ logger, discovery, catalog }) {
-        catalog.addProcessor(new PagerDutyEntityProcessor({ logger, discovery }));
-      }
-    });
-  }
-});
-
-exports.default = pagerDutyEntityProcessor;
+exports.default = module$1.pagerDutyEntityProcessor;
 //# sourceMappingURL=index.cjs.js.map