@electrolux-oss/plugin-infrawallet-backend 0.1.12 → 0.2.0

package/dist/index.cjs.js

@@ -6,19 +6,19 @@ var backendCommon = require('@backstage/backend-common');
 var backendPluginApi = require('@backstage/backend-plugin-api');
 var express = require('express');
 var Router = require('express-promise-router');
+var moment = require('moment');
 var clientCostExplorer = require('@aws-sdk/client-cost-explorer');
 var clientSts = require('@aws-sdk/client-sts');
 var lodash = require('lodash');
-var moment = require('moment');
 var armCostmanagement = require('@azure/arm-costmanagement');
 var coreRestPipeline = require('@azure/core-rest-pipeline');
 var identity = require('@azure/identity');
-var bigquery = require('@google-cloud/bigquery');
 var datadogApiClient = require('@datadog/datadog-api-client');
-var fetch$1 = require('node-fetch');
+var bigquery = require('@google-cloud/bigquery');
 var fs = require('fs');
 var upath = require('upath');
 var urllib = require('urllib');
+var fetch$1 = require('node-fetch');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -43,9 +43,9 @@ function _interopNamespaceCompat(e) {
 var express__default = /*#__PURE__*/_interopDefaultCompat(express);
 var Router__default = /*#__PURE__*/_interopDefaultCompat(Router);
 var moment__default = /*#__PURE__*/_interopDefaultCompat(moment);
-var fetch__default = /*#__PURE__*/_interopDefaultCompat(fetch$1);
 var upath__namespace = /*#__PURE__*/_interopNamespaceCompat(upath);
 var urllib__default = /*#__PURE__*/_interopDefaultCompat(urllib);
+var fetch__default = /*#__PURE__*/_interopDefaultCompat(fetch$1);
 
 async function getWallet(database, walletName) {
   const client = await database.getClient();
@@ -74,8 +74,61 @@ async function deleteWalletMetricSetting(database, walletSetting) {
   return false;
 }
 
+async function getBudgets(database, walletName) {
+  const knex = await database.getClient();
+  const budgets = await knex.select("budgets.*").from("budgets").where("wallets.name", walletName).join("wallets", "budgets.wallet_id", "=", "wallets.id");
+  return budgets;
+}
+async function getBudget(database, walletName, provider) {
+  const knex = await database.getClient();
+  const budgets = await knex.select("budgets.*").from("budgets").where("budgets.provider", provider).where("wallets.name", walletName).join("wallets", "budgets.wallet_id", "=", "wallets.id");
+  return budgets;
+}
+async function upsertBudget(database, walletName, budget) {
+  const knex = await database.getClient();
+  const wallet = await knex.select("id").from("wallets").where("name", walletName).first();
+  budget.wallet_id = wallet.id;
+  const result = await knex("budgets").insert(budget).onConflict("id").merge();
+  if (result[0] > 0) {
+    return true;
+  }
+  return false;
+}
+
+async function createCustomCosts(database, data) {
+  const knex = await database.getClient();
+  const records = await knex("custom_costs").insert(data).returning("id");
+  return records.length;
+}
+async function getCustomCostsByDateRange(database, startDate, endDate) {
+  const knex = await database.getClient();
+  const records = await knex("custom_costs").whereBetween("usage_month", [
+    parseInt(moment__default.default(startDate).format("YYYYMM"), 10),
+    parseInt(moment__default.default(endDate).format("YYYYMM"), 10)
+  ]).select("*");
+  return records;
+}
+async function getCustomCosts(database) {
+  const knex = await database.getClient();
+  const records = await knex("custom_costs").select("*");
+  return records;
+}
+async function updateOrInsertCustomCost(database, data) {
+  const knex = await database.getClient();
+  const [record] = await knex("custom_costs").insert(data).onConflict("id").merge().returning("*");
+  return record;
+}
+async function deleteCustomCost(database, data) {
+  const knex = await database.getClient();
+  const result = await knex("custom_costs").where("id", data.id).del();
+  if (result > 0) {
+    return true;
+  }
+  return false;
+}
+
 function parseTags(tags) {
-  if (!tags || tags[0] !== "(" || tags[tags.length - 1] !== ")") {
+  if (!tags.startsWith("(") || !tags.endsWith(")")) {
     return [];
   }
   const tagString = tags.slice(1, -1);
@@ -189,7 +242,7 @@ async function setReportsToCache(cache, reports, provider, configKey, query, ttl
     query.endTime
   ].join("_");
   await cache.set(cacheKey, reports, {
-    ttl: ttl != null ? ttl : 60 * 60 * 2 * 1e3
+    ttl: ttl ?? 60 * 60 * 2 * 1e3
   });
 }
 async function setMetricsToCache(cache, metrics, provider, configKey, query, ttl) {
@@ -209,7 +262,7 @@ async function setMetricsToCache(cache, metrics, provider, configKey, query, ttl
 }
 function parseFilters(filters) {
   const result = {};
-  if (!filters || filters[0] !== "(" || filters[filters.length - 1] !== ")") {
+  if (!filters.startsWith("(") || !filters.endsWith(")")) {
     return result;
   }
   const filterString = filters.slice(1, -1);
@@ -230,6 +283,16 @@ function parseFilters(filters) {
   });
   return result;
 }
+function getDailyPeriodStringsForOneMonth(yyyymm) {
+  const dateOjb = moment__default.default(yyyymm.toString(), "YYYYMM");
+  const startOfMonth = moment__default.default(dateOjb).startOf("month");
+  const endOfMonth = moment__default.default(dateOjb).endOf("month");
+  const periods = [];
+  for (let date = startOfMonth; date.isBefore(endOfMonth) || date.isSame(endOfMonth); date.add(1, "day")) {
+    periods.push(date.format("YYYY-MM-DD"));
+  }
+  return periods;
+}
 
 class InfraWalletClient {
   constructor(provider, config, database, cache, logger) {
@@ -242,22 +305,64 @@ class InfraWalletClient {
   convertServiceName(serviceName) {
     return serviceName;
   }
+  evaluateIntegrationFilters(account, integrationConfig) {
+    const filters = [];
+    for (const filter of integrationConfig.getOptionalConfigArray("filters") || []) {
+      filters.push({
+        type: filter.getString("type"),
+        attribute: filter.getString("attribute"),
+        pattern: filter.getString("pattern")
+      });
+    }
+    return this.evaluateFilters(account, filters);
+  }
+  evaluateFilters(account, filters) {
+    if (!filters || filters.length === 0) {
+      return true;
+    }
+    let included = false;
+    let hasIncludeFilter = false;
+    for (const filter of filters) {
+      const regex = new RegExp(filter.pattern);
+      if (filter.type === "exclude" && regex.test(account)) {
+        return false;
+      }
+      if (filter.type === "include") {
+        hasIncludeFilter = true;
+        if (regex.test(account)) {
+          included = true;
+        }
+      }
+    }
+    if (hasIncludeFilter) {
+      return included;
+    }
+    return true;
+  }
+  // Get all cost allocation tag keys from one account
+  async fetchTagKeys(_integrationConfig, _client, _query) {
+    return { tagKeys: [], provider: this.provider };
+  }
+  // Get all tag values of the specified tag key from one account
+  async fetchTagValues(_integrationConfig, _client, _query, _tagKey) {
+    return { tagValues: [], provider: this.provider };
+  }
   // Get aggregated unique tag keys across all accounts of this cloud provider
   async getTagKeys(query) {
-    const accounts = this.config.getOptionalConfigArray(
+    const integrationConfigs = this.config.getOptionalConfigArray(
       `backend.infraWallet.integrations.${this.provider.toLowerCase()}`
     );
-    if (!accounts) {
+    if (!integrationConfigs) {
       return { tags: [], errors: [] };
     }
     const promises = [];
     const aggregatedTags = [];
     const errors = [];
-    for (const account of accounts) {
-      const accountName = account.getString("name");
-      const cachedTagKeys = await getTagKeysFromCache(this.cache, this.provider, accountName, query);
+    for (const integrationConfig of integrationConfigs) {
+      const integrationName = integrationConfig.getString("name");
+      const cachedTagKeys = await getTagKeysFromCache(this.cache, this.provider, integrationName, query);
       if (cachedTagKeys) {
-        this.logger.info(`Reuse ${this.provider}/${accountName} tag keys from cache`);
+        this.logger.info(`Reuse ${this.provider}/${integrationName} tag keys from cache`);
         for (const tag of cachedTagKeys) {
           if (!tagExists(aggregatedTags, tag)) {
             aggregatedTags.push(tag);
@@ -267,8 +372,8 @@ class InfraWalletClient {
       }
       const promise = (async () => {
         try {
-          const client = await this.initCloudClient(account);
-          const response = await this.fetchTagKeys(account, client, query);
+          const client = await this.initCloudClient(integrationConfig);
+          const response = await this.fetchTagKeys(integrationConfig, client, query);
           const tagKeysCache = [];
           for (const tagKey of response.tagKeys) {
             const tag = { key: tagKey, provider: response.provider };
@@ -277,12 +382,12 @@ class InfraWalletClient {
               aggregatedTags.push(tag);
             }
           }
-          await setTagKeysToCache(this.cache, tagKeysCache, this.provider, accountName, query);
+          await setTagKeysToCache(this.cache, tagKeysCache, this.provider, integrationName, query);
         } catch (e) {
           this.logger.error(e);
           errors.push({
             provider: this.provider,
-            name: `${this.provider}/${accountName}`,
+            name: `${this.provider}/${integrationName}`,
             error: e.message
           });
         }
@@ -290,27 +395,28 @@ class InfraWalletClient {
       promises.push(promise);
     }
     await Promise.all(promises);
+    aggregatedTags.sort((a, b) => `${a.provider}/${a.key}`.localeCompare(`${b.provider}/${b.key}`));
     return {
-      tags: aggregatedTags.sort((a, b) => `${a.provider}/${a.key}`.localeCompare(`${b.provider}/${b.key}`)),
+      tags: aggregatedTags,
       errors
     };
   }
   // Get aggregated tag values of the specified tag key across all accounts of this cloud provider
   async getTagValues(query, tagKey) {
-    const accounts = this.config.getOptionalConfigArray(
+    const integrationConfigs = this.config.getOptionalConfigArray(
       `backend.infraWallet.integrations.${this.provider.toLowerCase()}`
     );
-    if (!accounts) {
+    if (!integrationConfigs) {
       return { tags: [], errors: [] };
     }
     const promises = [];
     const aggregatedTags = [];
     const errors = [];
-    for (const account of accounts) {
-      const accountName = account.getString("name");
-      const cachedTagValues = await getTagValuesFromCache(this.cache, this.provider, accountName, tagKey, query);
+    for (const integrationConfig of integrationConfigs) {
+      const integrationName = integrationConfig.getString("name");
+      const cachedTagValues = await getTagValuesFromCache(this.cache, this.provider, integrationName, tagKey, query);
       if (cachedTagValues) {
-        this.logger.info(`Reuse ${this.provider}/${accountName}/${tagKey} tag values from cache`);
+        this.logger.info(`Reuse ${this.provider}/${integrationName}/${tagKey} tag values from cache`);
         for (const tag of cachedTagValues) {
           if (!tagExists(aggregatedTags, tag)) {
             aggregatedTags.push(tag);
@@ -320,8 +426,8 @@ class InfraWalletClient {
       }
       const promise = (async () => {
         try {
-          const client = await this.initCloudClient(account);
-          const response = await this.fetchTagValues(account, client, query, tagKey);
+          const client = await this.initCloudClient(integrationConfig);
+          const response = await this.fetchTagValues(integrationConfig, client, query, tagKey);
           const tagValuesCache = [];
           for (const tagValue of response.tagValues) {
             const tag = { key: tagKey, value: tagValue, provider: response.provider };
@@ -330,12 +436,12 @@ class InfraWalletClient {
               aggregatedTags.push(tag);
             }
           }
-          await setTagValuesToCache(this.cache, tagValuesCache, this.provider, accountName, tagKey, query);
+          await setTagValuesToCache(this.cache, tagValuesCache, this.provider, integrationName, tagKey, query);
         } catch (e) {
           this.logger.error(e);
           errors.push({
             provider: this.provider,
-            name: `${this.provider}/${accountName}`,
+            name: `${this.provider}/${integrationName}`,
             error: e.message
           });
         }
@@ -343,54 +449,55 @@ class InfraWalletClient {
       promises.push(promise);
     }
     await Promise.all(promises);
+    aggregatedTags.sort(
+      (a, b) => `${a.provider}/${a.key}=${a.value}`.localeCompare(`${b.provider}/${b.key}=${b.value}`)
+    );
     return {
-      tags: aggregatedTags.sort(
-        (a, b) => `${a.provider}/${a.key}=${a.value}`.localeCompare(`${b.provider}/${b.key}=${b.value}`)
-      ),
+      tags: aggregatedTags,
       errors
     };
   }
   async getCostReports(query) {
-    const accounts = this.config.getOptionalConfigArray(
+    const integrationConfigs = this.config.getOptionalConfigArray(
       `backend.infraWallet.integrations.${this.provider.toLowerCase()}`
     );
-    if (!accounts) {
+    if (!integrationConfigs) {
       return { reports: [], errors: [] };
     }
     const promises = [];
     const results = [];
     const errors = [];
-    for (const account of accounts) {
-      const accountName = account.getString("name");
-      const cachedCosts = await getReportsFromCache(this.cache, this.provider, accountName, query);
+    for (const integrationConfig of integrationConfigs) {
+      const integrationName = integrationConfig.getString("name");
+      const cachedCosts = await getReportsFromCache(this.cache, this.provider, integrationName, query);
       if (cachedCosts) {
-        this.logger.debug(`${this.provider}/${accountName} costs from cache`);
-        cachedCosts.map((cost) => {
+        this.logger.debug(`${this.provider}/${integrationName} costs from cache`);
+        cachedCosts.forEach((cost) => {
           results.push(cost);
         });
         continue;
       }
       const promise = (async () => {
         try {
-          const client = await this.initCloudClient(account);
-          const costResponse = await this.fetchCosts(account, client, query);
-          const transformedReports = await this.transformCostsData(account, query, costResponse);
+          const client = await this.initCloudClient(integrationConfig);
+          const costResponse = await this.fetchCosts(integrationConfig, client, query);
+          const transformedReports = await this.transformCostsData(integrationConfig, query, costResponse);
           await setReportsToCache(
             this.cache,
             transformedReports,
             this.provider,
-            accountName,
+            integrationName,
             query,
             getDefaultCacheTTL(CACHE_CATEGORY.COSTS, this.provider)
           );
-          transformedReports.map((value) => {
+          transformedReports.forEach((value) => {
             results.push(value);
           });
         } catch (e) {
           this.logger.error(e);
           errors.push({
             provider: this.provider,
-            name: `${this.provider}/${accountName}`,
+            name: `${this.provider}/${integrationName}`,
             error: e.message
           });
         }
@@ -405,17 +512,8 @@ class InfraWalletClient {
   }
 }
 
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => {
-  __defNormalProp$1(obj, key + "" , value);
-  return value;
-};
 class AwsClient extends InfraWalletClient {
-  constructor() {
-    super(...arguments);
-    __publicField$1(this, "accounts", /* @__PURE__ */ new Map());
-  }
+  accounts = /* @__PURE__ */ new Map();
   static create(config, database, cache, logger) {
     return new AwsClient(CLOUD_PROVIDER.AWS, config, database, cache, logger);
   }
@@ -445,46 +543,55 @@ class AwsClient extends InfraWalletClient {
     }
     return `${this.provider}/${convertedName}`;
   }
-  async initCloudClient(subAccountConfig) {
-    var _a, _b, _c;
-    const accountId = subAccountConfig.getString("accountId");
-    const assumedRoleName = subAccountConfig.getString("assumedRoleName");
-    const accessKeyId = subAccountConfig.getOptionalString("accessKeyId");
-    const accessKeySecret = subAccountConfig.getOptionalString("accessKeySecret");
-    let stsParams = {};
-    if (accessKeyId && accessKeySecret) {
-      stsParams = {
-        region: "us-east-1",
-        credentials: {
+  async initCloudClient(integrationConfig) {
+    const accountId = integrationConfig.getString("accountId");
+    const assumedRoleName = integrationConfig.getOptionalString("assumedRoleName");
+    const accessKeyId = integrationConfig.getOptionalString("accessKeyId");
+    const accessKeySecret = integrationConfig.getOptionalString("accessKeySecret");
+    const region = "us-east-1";
+    if (!accessKeyId && !accessKeySecret && !assumedRoleName) {
+      return new clientCostExplorer.CostExplorerClient({ region });
+    }
+    let credentials = void 0;
+    if (accessKeyId || accessKeySecret) {
+      if (accessKeyId && accessKeySecret) {
+        credentials = {
           accessKeyId,
           secretAccessKey: accessKeySecret
-        }
-      };
-    } else {
-      stsParams = {
-        region: "us-east-1"
-      };
+        };
+      } else {
+        throw new Error("Both accessKeyId and accessKeySecret must be provided");
+      }
     }
-    const client = new clientSts.STSClient(stsParams);
+    if (assumedRoleName === void 0) {
+      return new clientCostExplorer.CostExplorerClient({
+        region,
+        credentials
+      });
+    }
+    const client = new clientSts.STSClient({
+      region,
+      credentials
+    });
     const commandInput = {
       // AssumeRoleRequest
       RoleArn: `arn:aws:iam::${accountId}:role/${assumedRoleName}`,
-      RoleSessionName: "AssumeRoleSession1"
+      RoleSessionName: "InfraWallet"
     };
     const assumeRoleCommand = new clientSts.AssumeRoleCommand(commandInput);
     const assumeRoleResponse = await client.send(assumeRoleCommand);
     const awsCeClient = new clientCostExplorer.CostExplorerClient({
-      region: "us-east-1",
+      region,
       credentials: {
-        accessKeyId: (_a = assumeRoleResponse.Credentials) == null ? void 0 : _a.AccessKeyId,
-        secretAccessKey: (_b = assumeRoleResponse.Credentials) == null ? void 0 : _b.SecretAccessKey,
-        sessionToken: (_c = assumeRoleResponse.Credentials) == null ? void 0 : _c.SessionToken
+        accessKeyId: assumeRoleResponse.Credentials?.AccessKeyId,
+        secretAccessKey: assumeRoleResponse.Credentials?.SecretAccessKey,
+        sessionToken: assumeRoleResponse.Credentials?.SessionToken
       }
     });
     return awsCeClient;
   }
   async _fetchTags(client, query, tagKey) {
-    const results = [];
+    const tags = [];
     let nextPageToken = void 0;
     do {
       const input = {
@@ -498,23 +605,23 @@ class AwsClient extends InfraWalletClient {
       const response = await client.send(command);
       for (const tag of response.Tags) {
         if (tag) {
-          results.push(tag);
+          tags.push(tag);
         }
       }
       nextPageToken = response.NextPageToken;
     } while (nextPageToken);
-    results.sort();
-    return results;
+    tags.sort((a, b) => a.localeCompare(b));
+    return tags;
   }
-  async fetchTagKeys(_subAccountConfig, client, query) {
+  async fetchTagKeys(_integrationConfig, client, query) {
     const tagKeys = await this._fetchTags(client, query);
-    return { tagKeys, provider: CLOUD_PROVIDER.AWS };
+    return { tagKeys, provider: this.provider };
   }
-  async fetchTagValues(_subAccountConfig, client, query, tagKey) {
+  async fetchTagValues(_integrationConfig, client, query, tagKey) {
     const tagValues = await this._fetchTags(client, query, tagKey);
-    return { tagValues, provider: CLOUD_PROVIDER.AWS };
+    return { tagValues, provider: this.provider };
   }
-  async fetchCosts(_subAccountConfig, client, query) {
+  async fetchCosts(_integrationConfig, client, query) {
     let costAndUsageResults = [];
     let nextPageToken = void 0;
     let filterExpression = { Dimensions: { Key: clientCostExplorer.Dimension.RECORD_TYPE, Values: ["Usage"] } };
@@ -522,11 +629,15 @@ class AwsClient extends InfraWalletClient {
     if (tags.length) {
       let tagsExpression = {};
       if (tags.length === 1) {
-        tagsExpression = { Tags: { Key: tags[0].key, Values: [tags[0].value] } };
+        if (tags[0].value) {
+          tagsExpression = { Tags: { Key: tags[0].key, Values: [tags[0].value] } };
+        }
       } else {
         const tagList = [];
         for (const tag of tags) {
-          tagList.push({ Tags: { Key: tag.key, Values: [tag.value] } });
+          if (tag.value) {
+            tagList.push({ Tags: { Key: tag.key, Values: [tag.value] } });
+          }
         }
         tagsExpression = { Or: tagList };
       }
@@ -559,19 +670,18 @@ class AwsClient extends InfraWalletClient {
     } while (nextPageToken);
     return costAndUsageResults;
   }
-  async transformCostsData(subAccountConfig, query, costResponse) {
+  async transformCostsData(integrationConfig, query, costResponse) {
     const categoryMappingService = CategoryMappingService.getInstance();
-    const tags = subAccountConfig.getOptionalStringArray("tags");
+    const tags = integrationConfig.getOptionalStringArray("tags");
     const tagKeyValues = {};
-    tags == null ? void 0 : tags.forEach((tag) => {
+    tags?.forEach((tag) => {
       const [k, v] = tag.split(":");
       tagKeyValues[k.trim()] = v.trim();
     });
     const transformedData = lodash.reduce(
       costResponse,
       (accumulator, row) => {
-        var _a;
-        const rowTime = (_a = row.TimePeriod) == null ? void 0 : _a.Start;
+        const rowTime = row.TimePeriod?.Start;
         let period = "unknown";
         if (rowTime) {
           if (query.granularity.toUpperCase() === "MONTHLY") {
@@ -582,9 +692,11 @@ class AwsClient extends InfraWalletClient {
         }
         if (row.Groups) {
           row.Groups.forEach((group) => {
-            var _a2;
             const accountId = group.Keys ? group.Keys[0] : "";
             const accountName = this.accounts.get(accountId) || accountId;
+            if (!this.evaluateIntegrationFilters(accountName, integrationConfig)) {
+              return;
+            }
             const serviceName = group.Keys ? group.Keys[1] : "";
             const keyName = `${accountId}_${serviceName}`;
             if (!accumulator[keyName]) {
@@ -594,13 +706,14 @@ class AwsClient extends InfraWalletClient {
                 service: this.convertServiceName(serviceName),
                 category: categoryMappingService.getCategoryByServiceName(this.provider, serviceName),
                 provider: this.provider,
+                providerType: PROVIDER_TYPE.INTEGRATION,
                 reports: {},
                 ...tagKeyValues
               };
             }
             const groupMetrics = group.Metrics;
             if (groupMetrics !== void 0) {
-              accumulator[keyName].reports[period] = parseFloat((_a2 = groupMetrics.UnblendedCost.Amount) != null ? _a2 : "0.0");
+              accumulator[keyName].reports[period] = parseFloat(groupMetrics.UnblendedCost.Amount ?? "0.0");
             }
           });
         }
@@ -694,13 +807,11 @@ class AzureClient extends InfraWalletClient {
         if (row[0] && !row[0].startsWith("hidden-")) {
           tags.push(row[0]);
         }
-      } else {
-        if (row[1]) {
-          tags.push(row[1]);
-        }
+      } else if (row[1]) {
+        tags.push(row[1]);
       }
     }
-    tags.sort();
+    tags.sort((a, b) => a.localeCompare(b));
     return tags;
   }
   async initCloudClient(config) {
@@ -713,11 +824,11 @@ class AzureClient extends InfraWalletClient {
   }
   async fetchTagKeys(subAccountConfig, client, query) {
     const tagKeys = await this._fetchTags(subAccountConfig, client, query, "");
-    return { tagKeys, provider: CLOUD_PROVIDER.AZURE };
+    return { tagKeys, provider: this.provider };
   }
   async fetchTagValues(subAccountConfig, client, query, tagKey) {
     const tagValues = await this._fetchTags(subAccountConfig, client, query, tagKey);
-    return { tagValues, provider: CLOUD_PROVIDER.AZURE };
+    return { tagValues, provider: this.provider };
   }
   async fetchCosts(subAccountConfig, client, query) {
     const subscriptionId = subAccountConfig.getString("subscriptionId");
@@ -727,13 +838,17 @@ class AzureClient extends InfraWalletClient {
     const tags = parseTags(query.tags);
     if (tags.length) {
       if (tags.length === 1) {
-        filter = {
-          tags: { name: tags[0].key, operator: "In", values: [tags[0].value] }
-        };
+        if (tags[0].value) {
+          filter = {
+            tags: { name: tags[0].key, operator: "In", values: [tags[0].value] }
+          };
+        }
       } else {
         const tagList = [];
         for (const tag of tags) {
-          tagList.push({ tags: { name: tag.key, operator: "In", values: [tag.value] } });
+          if (tag.value) {
+            tagList.push({ tags: { name: tag.key, operator: "In", values: [tag.value] } });
+          }
         }
         filter = { or: tagList };
       }
@@ -767,7 +882,7 @@ class AzureClient extends InfraWalletClient {
     const groupPairs = [{ type: "Dimension", name: "ServiceName" }];
     const tags = subAccountConfig.getOptionalStringArray("tags");
     const tagKeyValues = {};
-    tags == null ? void 0 : tags.forEach((tag) => {
+    tags?.forEach((tag) => {
       const [k, v] = tag.split(":");
       tagKeyValues[k.trim()] = v.trim();
     });
@@ -791,6 +906,7 @@ class AzureClient extends InfraWalletClient {
             service: this.convertServiceName(serviceName),
             category: categoryMappingService.getCategoryByServiceName(this.provider, serviceName),
             provider: this.provider,
+            providerType: PROVIDER_TYPE.INTEGRATION,
             reports: {},
             ...tagKeyValues
           };
@@ -811,13 +927,13 @@ class AzureClient extends InfraWalletClient {
   }
 }
 
-class GCPClient extends InfraWalletClient {
+class ConfluentClient extends InfraWalletClient {
   static create(config, database, cache, logger) {
-    return new GCPClient(CLOUD_PROVIDER.GCP, config, database, cache, logger);
+    return new ConfluentClient(CLOUD_PROVIDER.CONFLUENT, config, database, cache, logger);
   }
   convertServiceName(serviceName) {
     let convertedName = serviceName;
-    const prefixes = ["Google Cloud"];
+    const prefixes = ["Confluent"];
     for (const prefix of prefixes) {
       if (serviceName.startsWith(prefix)) {
         convertedName = serviceName.slice(prefix.length).trim();
@@ -825,183 +941,304 @@ class GCPClient extends InfraWalletClient {
     }
     return `${this.provider}/${convertedName}`;
   }
-  async initCloudClient(subAccountConfig) {
-    const keyFilePath = subAccountConfig.getString("keyFilePath");
-    const projectId = subAccountConfig.getString("projectId");
-    const options = {
-      keyFilename: keyFilePath,
-      projectId
-    };
-    const bigqueryClient = new bigquery.BigQuery(options);
-    return bigqueryClient;
+  capitalizeWords(str) {
+    return str.toLowerCase().split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
   }
-  async fetchTagKeys(_subAccountConfig, _client, _query) {
-    return { tagKeys: [], provider: CLOUD_PROVIDER.GCP };
+  async fetchEnvDisplayName(client, envId) {
+    const url = `https://api.confluent.cloud/org/v2/environments/${envId}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: client.headers
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch environment name for ${envId}: ${response.statusText}`);
+    }
+    const jsonResponse = await response.json();
+    return jsonResponse.display_name;
   }
-  async fetchTagValues(_subAccountConfig, _client, _query, _tagKey) {
-    return { tagValues: [], provider: CLOUD_PROVIDER.GCP };
+  async initCloudClient(subAccountConfig) {
+    const apiKey = subAccountConfig.getString("apiKey");
+    const apiSecret = subAccountConfig.getString("apiSecret");
+    const auth = `${apiKey}:${apiSecret}`;
+    const client = {
+      headers: {
+        Authorization: `Basic ${Buffer.from(auth).toString("base64")}`,
+        "Content-Type": "application/json"
+      }
+    };
+    return client;
   }
-  async fetchCosts(subAccountConfig, client, query) {
-    const projectId = subAccountConfig.getString("projectId");
-    const datasetId = subAccountConfig.getString("datasetId");
-    const tableId = subAccountConfig.getString("tableId");
+  async fetchCosts(_subAccountConfig, client, query) {
+    const startDate = moment__default.default(parseInt(query.startTime, 10));
+    const endDate = moment__default.default(parseInt(query.endTime, 10));
+    const currentStartDate = startDate.clone();
+    let aggregatedData = [];
     try {
-      const periodFormat = query.granularity.toUpperCase() === "MONTHLY" ? "%Y-%m" : "%Y-%m-%d";
-      const sql = `
-        SELECT
-          project.name AS project,
-          service.description AS service,
-          FORMAT_TIMESTAMP('${periodFormat}', usage_start_time) AS period,
-          (SUM(CAST(cost AS NUMERIC)) + SUM(IFNULL((SELECT SUM(CAST(c.amount AS NUMERIC)) FROM UNNEST(credits) AS c), 0))) AS total_cost
-        FROM
-          \`${projectId}.${datasetId}.${tableId}\`
-        WHERE
-          project.name IS NOT NULL
-          AND cost > 0
-          AND usage_start_time >= TIMESTAMP_MILLIS(${query.startTime})
-          AND usage_start_time <= TIMESTAMP_MILLIS(${query.endTime})
-        GROUP BY
-          project, service, period
-        ORDER BY
-          project, period, total_cost DESC`;
-      const [job] = await client.createQueryJob({
-        query: sql
-      });
-      const [rows] = await job.getQueryResults();
-      return rows;
-    } catch (err) {
-      throw new Error(err.message);
+      while (currentStartDate.isBefore(endDate) || currentStartDate.isSame(endDate, "month")) {
+        const currentEndDate = moment__default.default.min(currentStartDate.clone().endOf("month"), endDate);
+        const url = `https://api.confluent.cloud/billing/v1/costs?start_date=${currentStartDate.format(
+          "YYYY-MM-DD"
+        )}&end_date=${currentEndDate.add("1", "d").format("YYYY-MM-DD")}`;
+        const response = await fetch(url, {
+          method: "GET",
+          headers: client.headers
+        });
+        if (!response.ok) {
+          throw new Error(`Failed to fetch costs: ${response.statusText}`);
+        }
+        const jsonResponse = await response.json();
+        const envIds = [...new Set(jsonResponse.data.map((item) => item.resource.environment.id))];
+        const envNamePromises = envIds.map((envId) => this.fetchEnvDisplayName(client, envId));
+        const envNames = await Promise.all(envNamePromises);
+        const envIdToName = {};
+        envIds.forEach((envId, index) => {
+          envIdToName[envId] = envNames[index];
+        });
+        const dataWithEnvNames = jsonResponse.data.map((item) => {
+          const envId = item.resource.environment.id;
+          return {
+            ...item,
+            envDisplayName: envIdToName[envId] || "Unknown"
+          };
+        });
+        aggregatedData = aggregatedData.concat(dataWithEnvNames);
+        currentStartDate.add(1, "month").startOf("month");
+      }
+      return {
+        data: aggregatedData
+      };
+    } catch (error) {
+      this.logger.error(`Error fetching costs from Confluent: ${error.message}`);
+      throw error;
     }
   }
-  async transformCostsData(subAccountConfig, _query, costResponse) {
+  async transformCostsData(subAccountConfig, query, costResponse) {
     const categoryMappingService = CategoryMappingService.getInstance();
     const accountName = subAccountConfig.getString("name");
     const tags = subAccountConfig.getOptionalStringArray("tags");
     const tagKeyValues = {};
-    tags == null ? void 0 : tags.forEach((tag) => {
+    tags?.forEach((tag) => {
       const [k, v] = tag.split(":");
       tagKeyValues[k.trim()] = v.trim();
     });
-    const transformedData = lodash.reduce(
-      costResponse,
-      (acc, row) => {
-        const period = row.period;
-        const keyName = `${accountName}_${row.project}_${row.service}`;
-        if (!acc[keyName]) {
-          acc[keyName] = {
-            id: keyName,
-            account: `${this.provider}/${accountName}`,
-            service: this.convertServiceName(row.service),
-            category: categoryMappingService.getCategoryByServiceName(this.provider, row.service),
-            provider: this.provider,
-            reports: {},
-            ...{ project: row.project },
-            // TODO: how should we handle the project field? for now, we add project name as a field in the report
-            ...tagKeyValues
-            // note that if there is a tag `project:foo` in config, it overrides the project field set above
-          };
-        }
-        acc[keyName].reports[period] = parseFloat(row.total_cost);
-        return acc;
-      },
-      {}
-    );
+    const transformedData = costResponse.data.reduce((accumulator, line) => {
+      const amount = parseFloat(line.amount) || 0;
+      if (amount === 0) {
+        return accumulator;
+      }
+      const parsedStartDate = moment__default.default(line.start_date);
+      if (!parsedStartDate.isValid()) {
+        return accumulator;
+      }
+      let billingPeriod = void 0;
+      if (query.granularity.toUpperCase() === "MONTHLY") {
+        billingPeriod = parsedStartDate.format("YYYY-MM");
+      } else {
+        billingPeriod = parsedStartDate.format("YYYY-MM-DD");
+      }
+      const serviceName = this.capitalizeWords(line.line_type);
+      const resourceName = line.resource.display_name || "Unknown";
+      const envDisplayName = line.envDisplayName;
+      const keyName = `${accountName}->${categoryMappingService.getCategoryByServiceName(
+        this.provider,
+        serviceName
+      )}->${resourceName}`;
+      if (!accumulator[keyName]) {
+        accumulator[keyName] = {
+          id: keyName,
+          account: `${this.provider}/${accountName}`,
+          service: this.convertServiceName(serviceName),
+          category: categoryMappingService.getCategoryByServiceName(this.provider, serviceName),
+          provider: this.provider,
+          providerType: PROVIDER_TYPE.INTEGRATION,
+          reports: {},
+          ...{ project: envDisplayName },
+          ...{ cluster: resourceName },
+          ...tagKeyValues
+        };
+      }
+      if (!moment__default.default(billingPeriod).isBefore(moment__default.default(parseInt(query.startTime, 10)))) {
+        accumulator[keyName].reports[billingPeriod] = (accumulator[keyName].reports[billingPeriod] || 0) + amount;
+      }
+      return accumulator;
+    }, {});
     return Object.values(transformedData);
   }
 }
 
-class MetricProvider {
-  constructor(providerName, config, database, cache, logger) {
-    this.providerName = providerName;
-    this.config = config;
-    this.database = database;
-    this.cache = cache;
-    this.logger = logger;
+class CustomProviderClient extends InfraWalletClient {
+  static create(config, database, cache, logger) {
+    return new CustomProviderClient(CLOUD_PROVIDER.CUSTOM, config, database, cache, logger);
   }
-  async getMetrics(query) {
-    const conf = this.config.getOptionalConfigArray(
-      `backend.infraWallet.metricProviders.${this.providerName.toLowerCase()}`
+  async initCloudClient(_config) {
+    return null;
+  }
+  async fetchCosts(_integrationConfig, _client, query) {
+    const records = getCustomCostsByDateRange(
+      this.database,
+      moment__default.default(parseInt(query.startTime, 10)).toDate(),
+      moment__default.default(parseInt(query.endTime, 10)).toDate()
     );
-    if (!conf) {
-      return { metrics: [], errors: [] };
-    }
-    const promises = [];
-    const results = [];
-    const errors = [];
-    for (const c of conf) {
-      const configName = c.getString("name");
-      const client = await this.initProviderClient(c);
-      const dbClient = await this.database.getClient();
-      const metricSettings = await dbClient.where({
-        "wallets.name": query.walletName,
-        "business_metrics.metric_provider": this.providerName.toLowerCase(),
-        "business_metrics.config_name": configName
-      }).select("business_metrics.*").from("business_metrics").join("wallets", "business_metrics.wallet_id", "=", "wallets.id");
-      for (const metric of metricSettings || []) {
-        const promise = (async () => {
+    return records;
+  }
+  async transformCostsData(_subAccountConfig, query, costResponse) {
+    const transformedData = lodash.reduce(
+      costResponse,
+      (accumulator, record) => {
+        let periodFormat = "YYYY-MM";
+        if (query.granularity === GRANULARITY.DAILY) {
+          periodFormat = "YYYY-MM-DD";
+        }
+        const keyName = `${record.provider}-${record.account}-${record.service}`;
+        if (typeof record.tags === "string") {
           try {
-            const fullQuery = {
-              name: metric.metric_name,
-              query: metric.query,
-              ...query
-            };
-            const cachedMetrics = await getMetricsFromCache(this.cache, this.providerName, configName, fullQuery);
-            if (cachedMetrics) {
-              this.logger.debug(`${this.providerName}/${configName}/${fullQuery.name} metrics from cache`);
-              cachedMetrics.map((m) => {
-                results.push({
-                  group: metric.group,
-                  // add group info to the metric
-                  ...m
-                });
-              });
-              return;
-            }
-            const metricResponse = await this.fetchMetrics(c, client, fullQuery);
-            const transformedMetrics = await this.transformMetricData(c, fullQuery, metricResponse);
-            await setMetricsToCache(
-              this.cache,
-              transformedMetrics,
-              this.providerName,
-              configName,
-              fullQuery,
-              60 * 60 * 2 * 1e3
-            );
-            transformedMetrics.map((value) => {
-              results.push({
-                group: metric.group,
-                // add group info to the metric
-                ...value
-              });
-            });
-          } catch (e) {
-            this.logger.error(e);
-            errors.push({
-              provider: this.providerName,
-              name: `${this.providerName}/${configName}/${metric.getString("metricName")}`,
-              error: e.message
+            record.tags = JSON.parse(record.tags);
+          } catch (error) {
+            this.logger.error(`Failed to parse tags for custom cost ${keyName}, tags: ${record.tags}`);
+            record.tags = {};
+          }
+        }
+        if (!accumulator[keyName]) {
+          accumulator[keyName] = {
+            id: keyName,
+            account: record.account,
+            service: record.service,
+            category: record.category,
+            provider: record.provider,
+            providerType: PROVIDER_TYPE.CUSTOM,
+            reports: {}
+          };
+        }
+        accumulator[keyName] = { ...accumulator[keyName], ...record.tags };
+        const cost = parseFloat(record.cost);
+        if (query.granularity === GRANULARITY.MONTHLY) {
+          const period = moment__default.default(record.usage_month.toString(), "YYYYMM").format(periodFormat);
+          accumulator[keyName].reports[period] = cost;
+        } else {
+          if (record.amortization_mode === "average") {
+            const periods = getDailyPeriodStringsForOneMonth(record.usage_month);
+            const averageCost = parseFloat(record.cost) / periods.length;
+            periods.forEach((period) => {
+              accumulator[keyName].reports[period] = averageCost;
             });
+          } else if (record.amortization_mode === "start_day") {
+            const period = moment__default.default(record.usage_month.toString(), "YYYYMM").startOf("month").format(periodFormat);
+            accumulator[keyName].reports[period] = cost;
+          } else {
+            const period = moment__default.default(record.usage_month.toString(), "YYYYMM").endOf("month").format(periodFormat);
+            accumulator[keyName].reports[period] = cost;
           }
-        })();
-        promises.push(promise);
-      }
+        }
+        return accumulator;
+      },
+      {}
+    );
+    return Object.values(transformedData);
+  }
+  // override this method so that we do not read from the config file
+  async getCostReports(query) {
+    const results = [];
+    const errors = [];
+    const cachedCosts = await getReportsFromCache(this.cache, this.provider, "custom", query);
+    if (cachedCosts) {
+      this.logger.debug(`${this.provider} costs from cache`);
+      cachedCosts.forEach((cost) => {
+        results.push(cost);
+      });
+    }
+    try {
+      const costResponse = await this.fetchCosts(null, null, query);
+      const transformedReports = await this.transformCostsData(null, query, costResponse);
+      await setReportsToCache(
+        this.cache,
+        transformedReports,
+        this.provider,
+        "custom",
+        query,
+        getDefaultCacheTTL(CACHE_CATEGORY.COSTS, this.provider)
+      );
+      transformedReports.forEach((value) => {
+        results.push(value);
+      });
+    } catch (e) {
+      this.logger.error(e);
+      errors.push({
+        provider: this.provider,
+        name: this.provider,
+        error: e.message
+      });
     }
-    await Promise.all(promises);
     return {
-      metrics: results,
+      reports: results,
       errors
     };
   }
 }
 
-class DatadogProvider extends MetricProvider {
+class DatadogClient extends InfraWalletClient {
   static create(config, database, cache, logger) {
-    return new DatadogProvider("Datadog", config, database, cache, logger);
+    return new DatadogClient(CLOUD_PROVIDER.DATADOG, config, database, cache, logger);
   }
-  async initProviderClient(config) {
-    const apiKey = config.getString("apiKey");
-    const applicationKey = config.getString("applicationKey");
-    const ddSite = config.getString("ddSite");
+  convertServiceName(serviceName) {
+    let convertedName = serviceName;
+    const aliases = /* @__PURE__ */ new Map([
+      ["apm_host", "APM Hosts"],
+      ["apm_host_enterprise", "APM Enterprise Hosts"],
+      ["application_vulnerability_management_oss_host", "Application Security - SCA Host"],
+      ["application_security_host", "ASM - Threat Management Hosts"],
+      ["audit_trail", "Audit Trail"],
+      ["ci_pipeline", "CI Visibility Committers"],
+      ["ci_pipeline_indexed_spans", "CI Visibility Spans"],
+      ["cloud_cost_management", "Cloud Cost Hosts"],
+      ["cspm_container", "Cloud Security Management Containers Pro"],
+      ["cspm_host", "Cloud Security Management Hosts Pro"],
+      ["csm_host_pro", "Cloud Security Management Hosts Pro"],
+      ["cws_host", "Cloud Workload Security Hosts"],
+      ["infra_container", "Containers"],
+      ["infra_container_excl_agent", "Containers"],
+      ["timeseries", "Custom Metrics"],
+      ["error_tracking", "Error Tracking"],
+      ["incident_management", "Incident Management"],
+      ["logs_indexed_15day", "Indexed Logs (15-day Retention)"],
+      ["logs_indexed_180day", "Indexed Logs (180-day Retention)"],
+      ["logs_indexed_1day", "Indexed Logs (1-day Retention)"],
+      ["logs_indexed_30day", "Indexed Logs (30-day Retention)"],
+      ["logs_indexed_360day", "Indexed Logs (360-day Retention)"],
+      ["logs_indexed_3day", "Indexed Logs (3-day Retention)"],
+      ["logs_indexed_45day", "Indexed Logs (45-day Retention)"],
+      ["logs_indexed_60day", "Indexed Logs (60-day Retention)"],
+      ["logs_indexed_7day", "Indexed Logs (7-day Retention)"],
+      ["logs_indexed_90day", "Indexed Logs (90-day Retention)"],
+      ["apm_trace_search", "Indexed Spans"],
+      ["infra_host", "Infra Hosts"],
+      ["logs_ingested", "Ingested Logs"],
+      ["ingested_spans", "Ingested Spans"],
+      ["iot", "IoT Devices"],
+      ["npm_host", "Network Hosts"],
+      ["prof_container", "Profiled Containers"],
+      ["prof_host", "Profiled Hosts"],
+      ["rum_lite", "RUM Sessions"],
+      ["rum_replay", "RUM with Session Replay Sessions"],
+      ["siem_indexed", "Security Analyzed and Indexed Logs"],
+      ["sensitive_data_scanner", "Sensitive Data Scanner"],
+      ["serverless_apps", "Serverless App Instances"],
+      ["serverless_apm", "Serverless Traced Invocations"],
+      ["serverless_infra", "Serverless Workload Functions"],
+      ["siem", "SIEM - Analyzed Logs"],
+      ["synthetics_api_tests", "Synthetics API Test Runs"],
+      ["synthetics_browser_checks", "Synthetics Browser Test Runs"],
+      ["ci_testing", "Test Visibility Committers"],
+      ["ci_test_indexed_spans", "Test Visibility Spans"]
+    ]);
+    if (aliases.has(convertedName)) {
+      convertedName = aliases.get(convertedName) || convertedName;
+    }
+    return `${this.provider}/${convertedName}`;
+  }
+  async initCloudClient(integrationConfig) {
+    const apiKey = integrationConfig.getString("apiKey");
+    const applicationKey = integrationConfig.getString("applicationKey");
+    const ddSite = integrationConfig.getString("ddSite");
     const configuration = datadogApiClient.client.createConfiguration({
       baseServer: new datadogApiClient.client.BaseServerConfiguration(ddSite, {}),
       authMethods: {
@@ -1009,138 +1246,218 @@ class DatadogProvider extends MetricProvider {
         appKeyAuth: applicationKey
       }
     });
-    const client = new datadogApiClient.v1.MetricsApi(configuration);
+    const client = new datadogApiClient.v2.UsageMeteringApi(configuration);
     return client;
   }
-  async fetchMetrics(_metricProviderConfig, client, query) {
-    var _a;
-    const params = {
-      from: parseInt(query.startTime, 10) / 1e3,
-      to: parseInt(query.endTime, 10) / 1e3,
-      query: (_a = query.query) == null ? void 0 : _a.replaceAll("IW_INTERVAL", query.granularity === "daily" ? "86400" : "2592000")
-    };
-    return client.queryMetrics(params).then((data) => {
-      if (data.status === "ok") {
-        return data;
+  async fetchCosts(integrationConfig, client, query) {
+    const costData = [];
+    const startTime = moment__default.default(parseInt(query.startTime, 10));
+    const endTime = moment__default.default(parseInt(query.endTime, 10));
+    const firstDayOfLastMonth = moment__default.default().subtract(1, "M").startOf("M");
+    if (startTime.isBefore(firstDayOfLastMonth)) {
+      const historicalCost = await client.getHistoricalCostByOrg({
+        startMonth: startTime,
+        endMonth: firstDayOfLastMonth.subtract(1, "d"),
+        view: "sub-org"
+      });
+      if (historicalCost.data) {
+        costData.push(...historicalCost.data);
       }
-      throw new Error(data.error);
-    });
-  }
-  async transformMetricData(_metricProviderConfig, query, metricResponse) {
-    const transformedData = [];
-    for (const series of metricResponse.series) {
-      const metricName = query.name;
-      const tagSet = series.tagSet;
-      const metric = {
-        id: `${metricName} ${tagSet.length === 0 ? "" : tagSet}`,
-        provider: this.providerName,
-        name: metricName,
-        reports: {}
-      };
-      for (const point of series.pointlist) {
-        const period = moment__default.default(point[0]).format(query.granularity === "daily" ? "YYYY-MM-DD" : "YYYY-MM");
-        const value = point[1];
-        metric.reports[period] = value;
+    }
+    if (endTime.isSameOrAfter(firstDayOfLastMonth)) {
+      let estimatedCostStartTime = startTime;
+      if (startTime.isBefore(firstDayOfLastMonth)) {
+        estimatedCostStartTime = firstDayOfLastMonth;
+      }
+      const estimatedCost = await client.getEstimatedCostByOrg({
+        startMonth: estimatedCostStartTime,
+        endMonth: endTime,
+        view: "sub-org"
+      });
+      if (estimatedCost.data) {
+        costData.push(...estimatedCost.data);
       }
-      transformedData.push(metric);
     }
-    return transformedData;
-  }
-}
-
-class GrafanaCloudProvider extends MetricProvider {
-  static create(config, database, cache, logger) {
-    return new GrafanaCloudProvider("GrafanaCloud", config, database, cache, logger);
-  }
-  async initProviderClient(_config) {
-    return null;
-  }
-  async fetchMetrics(metricProviderConfig, _client, query) {
-    var _a;
-    const url = metricProviderConfig.getString("url");
-    const datasourceUid = metricProviderConfig.getString("datasourceUid");
-    const token = metricProviderConfig.getString("token");
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    };
-    const payload = {
-      queries: [
-        {
-          datasource: {
-            uid: datasourceUid
-          },
-          expr: (_a = query.query) == null ? void 0 : _a.replaceAll("IW_INTERVAL", query.granularity === "daily" ? "1d" : "30d"),
-          refId: "A"
+    const costs = [];
+    if (query.granularity === GRANULARITY.MONTHLY) {
+      costData.forEach((costByOrg) => {
+        const orgName = costByOrg.attributes?.orgName;
+        if (!this.evaluateIntegrationFilters(orgName, integrationConfig)) {
+          return;
         }
-      ],
-      from: query.startTime,
-      to: query.endTime
-    };
-    const response = await fetch__default.default(`${url}/api/ds/query`, {
-      method: "post",
-      body: JSON.stringify(payload),
-      headers
-    });
-    const data = await response.json();
-    return data;
-  }
-  async transformMetricData(_metricProviderConfig, query, metricResponse) {
-    const transformedData = [];
-    const metricName = query.name;
-    const metric = {
-      id: metricName,
-      provider: this.providerName,
-      name: metricName,
-      reports: {}
-    };
-    const periods = metricResponse.results.A.frames[0].data.values[0];
-    const values = metricResponse.results.A.frames[0].data.values[1];
-    for (let i = 0; i < periods.length; i++) {
-      const period = moment__default.default(periods[i]).format(query.granularity === "daily" ? "YYYY-MM-DD" : "YYYY-MM");
-      const value = values[i];
-      metric.reports[period] = value;
+        costs.push({
+          orgName,
+          date: costByOrg.attributes?.date,
+          // only keep cost breakdown
+          charges: costByOrg.attributes?.charges?.filter((charge) => charge.chargeType !== "total")
+        });
+      });
+    } else {
+      costData.forEach((costByOrg) => {
+        const orgName = costByOrg.attributes?.orgName;
+        if (!this.evaluateIntegrationFilters(orgName, integrationConfig)) {
+          return;
+        }
+        const daysInMonth = moment__default.default(costByOrg.attributes?.date).daysInMonth();
+        costByOrg.attributes?.charges?.forEach((charge) => {
+          if (charge.chargeType === "total") {
+            return;
+          }
+          for (let i = 0; i < daysInMonth; i++) {
+            const dailyCost = {
+              orgName,
+              date: moment__default.default(costByOrg.attributes?.date).add(i, "d"),
+              charges: [
+                {
+                  productName: charge.productName,
+                  cost: (charge.cost || 0) / daysInMonth,
+                  chargeType: charge.chargeType
+                }
+              ]
+            };
+            costs.push(dailyCost);
+          }
+        });
+      });
     }
-    transformedData.push(metric);
-    return transformedData;
+    return costs;
+  }
+  async transformCostsData(subAccountConfig, query, costResponse) {
+    const tags = subAccountConfig.getOptionalStringArray("tags");
+    const tagKeyValues = {};
+    tags?.forEach((tag) => {
+      const [k, v] = tag.split(":");
+      tagKeyValues[k.trim()] = v.trim();
+    });
+    const transformedData = lodash.reduce(
+      costResponse,
+      (accumulator, costByOrg) => {
+        const account = costByOrg.orgName;
+        const charges = costByOrg.charges;
+        let periodFormat = "YYYY-MM";
+        if (query.granularity === GRANULARITY.DAILY) {
+          periodFormat = "YYYY-MM-DD";
+        }
+        const period = moment__default.default(costByOrg.date).format(periodFormat);
+        if (charges) {
+          charges.forEach((charge) => {
+            const productName = charge.productName;
+            const cost = charge.cost;
+            const keyName = `${account}->${productName} (${charge.chargeType})`;
+            if (!accumulator[keyName]) {
+              accumulator[keyName] = {
+                id: keyName,
+                account: `${this.provider}/${account}`,
+                service: `${this.convertServiceName(productName)} (${charge.chargeType})`,
+                category: "Observability",
+                provider: this.provider,
+                providerType: PROVIDER_TYPE.INTEGRATION,
+                reports: {},
+                ...tagKeyValues
+              };
+            }
+            accumulator[keyName].reports[period] = cost || 0;
+          });
+        }
+        return accumulator;
+      },
+      {}
+    );
+    return Object.values(transformedData);
   }
 }
 
-class MockProvider extends MetricProvider {
+class GCPClient extends InfraWalletClient {
   static create(config, database, cache, logger) {
-    return new MockProvider("Mock", config, database, cache, logger);
+    return new GCPClient(CLOUD_PROVIDER.GCP, config, database, cache, logger);
   }
-  async initProviderClient(_config) {
-    return null;
+  convertServiceName(serviceName) {
+    let convertedName = serviceName;
+    const prefixes = ["Google Cloud"];
+    for (const prefix of prefixes) {
+      if (serviceName.startsWith(prefix)) {
+        convertedName = serviceName.slice(prefix.length).trim();
+      }
+    }
+    return `${this.provider}/${convertedName}`;
   }
-  async fetchMetrics(_metricProviderConfig, _client, _query) {
-    return null;
+  async initCloudClient(subAccountConfig) {
+    const keyFilePath = subAccountConfig.getString("keyFilePath");
+    const projectId = subAccountConfig.getString("projectId");
+    const options = {
+      keyFilename: keyFilePath,
+      projectId
+    };
+    const bigqueryClient = new bigquery.BigQuery(options);
+    return bigqueryClient;
   }
-  async transformMetricData(_metricProviderConfig, query, _metricResponse) {
-    var _a, _b;
-    const transformedData = [];
-    const metricName = query.name;
-    let mockSettings = {};
+  async fetchCosts(subAccountConfig, client, query) {
+    const projectId = subAccountConfig.getString("projectId");
+    const datasetId = subAccountConfig.getString("datasetId");
+    const tableId = subAccountConfig.getString("tableId");
     try {
-      mockSettings = JSON.parse(query.query);
-    } catch (e) {
-    }
-    const minValue = (_a = mockSettings.min) != null ? _a : 0;
-    const maxValue = (_b = mockSettings.max) != null ? _b : 1e3;
-    const metric = {
-      id: metricName,
-      provider: this.providerName,
-      name: metricName,
-      reports: {}
-    };
-    let cursor = moment__default.default(parseInt(query.startTime, 10));
-    while (cursor <= moment__default.default(parseInt(query.endTime, 10))) {
-      const period = cursor.format(query.granularity === "daily" ? "YYYY-MM-DD" : "YYYY-MM");
-      metric.reports[period] = Math.floor(Math.random() * (maxValue - minValue) + minValue);
-      cursor = cursor.add(1, query.granularity === "daily" ? "days" : "months");
+      const periodFormat = query.granularity.toUpperCase() === "MONTHLY" ? "%Y-%m" : "%Y-%m-%d";
+      const sql = `
+        SELECT
+          project.name AS project,
+          service.description AS service,
+          FORMAT_TIMESTAMP('${periodFormat}', usage_start_time) AS period,
+          (SUM(CAST(cost AS NUMERIC)) + SUM(IFNULL((SELECT SUM(CAST(c.amount AS NUMERIC)) FROM UNNEST(credits) AS c), 0))) AS total_cost
+        FROM
+          \`${projectId}.${datasetId}.${tableId}\`
+        WHERE
+          project.name IS NOT NULL
+          AND cost > 0
+          AND usage_start_time >= TIMESTAMP_MILLIS(${query.startTime})
+          AND usage_start_time <= TIMESTAMP_MILLIS(${query.endTime})
+        GROUP BY
+          project, service, period
+        ORDER BY
+          project, period, total_cost DESC`;
+      const [job] = await client.createQueryJob({
+        query: sql
+      });
+      const [rows] = await job.getQueryResults();
+      return rows;
+    } catch (err) {
+      throw new Error(err.message);
     }
-    transformedData.push(metric);
-    return transformedData;
+  }
+  async transformCostsData(subAccountConfig, _query, costResponse) {
+    const categoryMappingService = CategoryMappingService.getInstance();
+    const accountName = subAccountConfig.getString("name");
+    const tags = subAccountConfig.getOptionalStringArray("tags");
+    const tagKeyValues = {};
+    tags?.forEach((tag) => {
+      const [k, v] = tag.split(":");
+      tagKeyValues[k.trim()] = v.trim();
+    });
+    const transformedData = lodash.reduce(
+      costResponse,
+      (acc, row) => {
+        const period = row.period;
+        const keyName = `${accountName}_${row.project}_${row.service}`;
+        if (!acc[keyName]) {
+          acc[keyName] = {
+            id: keyName,
+            account: `${this.provider}/${accountName}`,
+            service: this.convertServiceName(row.service),
+            category: categoryMappingService.getCategoryByServiceName(this.provider, row.service),
+            provider: this.provider,
+            providerType: PROVIDER_TYPE.INTEGRATION,
+            reports: {},
+            ...{ project: row.project },
+            // TODO: how should we handle the project field? for now, we add project name as a field in the report
+            ...tagKeyValues
+            // note that if there is a tag `project:foo` in config, it overrides the project field set above
+          };
+        }
+        acc[keyName].reports[period] = parseFloat(row.total_cost);
+        return acc;
+      },
+      {}
+    );
+    return Object.values(transformedData);
   }
 }
 
@@ -1152,12 +1469,6 @@ class MockClient extends InfraWalletClient {
     this.logger.debug(`MockClient.initCloudClient called with config: ${JSON.stringify(config)}`);
     return null;
   }
-  async fetchTagKeys(_subAccountConfig, _client, _query) {
-    return { tagKeys: [], provider: CLOUD_PROVIDER.MOCK };
-  }
-  async fetchTagValues(_subAccountConfig, _client, _query, _tagKey) {
-    return { tagValues: [], provider: CLOUD_PROVIDER.MOCK };
-  }
   async fetchCosts(_subAccountConfig, _client, _query) {
     return null;
   }
@@ -1176,14 +1487,12 @@ class MockClient extends InfraWalletClient {
       }
       const processedData = await Promise.all(
         jsonData.map(async (item) => {
+          item.providerType = PROVIDER_TYPE.INTEGRATION;
           item.reports = {};
           const StartDate = moment__default.default(startD);
-          let step;
+          let step = "months";
           let dateFormat = "YYYY-MM";
-          if (query.granularity.toLowerCase() === "monthly") {
-            step = "months";
-            dateFormat = "YYYY-MM";
-          } else if (query.granularity.toLowerCase() === "daily") {
+          if (query.granularity.toLowerCase() === "daily") {
             step = "days";
             dateFormat = "YYYY-MM-DD";
           }
@@ -1212,150 +1521,6 @@ class MockClient extends InfraWalletClient {
   }
 }
 
-class ConfluentClient extends InfraWalletClient {
-  static create(config, database, cache, logger) {
-    return new ConfluentClient(CLOUD_PROVIDER.CONFLUENT, config, database, cache, logger);
-  }
-  convertServiceName(serviceName) {
-    let convertedName = serviceName;
-    const prefixes = ["Confluent"];
-    for (const prefix of prefixes) {
-      if (serviceName.startsWith(prefix)) {
-        convertedName = serviceName.slice(prefix.length).trim();
-      }
-    }
-    return `${this.provider}/${convertedName}`;
-  }
-  capitalizeWords(str) {
-    return str.toLowerCase().split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-  }
-  async fetchEnvDisplayName(client, envId) {
-    const url = `https://api.confluent.cloud/org/v2/environments/${envId}`;
-    const response = await fetch(url, {
-      method: "GET",
-      headers: client.headers
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to fetch environment name for ${envId}: ${response.statusText}`);
-    }
-    const jsonResponse = await response.json();
-    return jsonResponse.display_name;
-  }
-  async initCloudClient(subAccountConfig) {
-    const apiKey = subAccountConfig.getString("apiKey");
-    const apiSecret = subAccountConfig.getString("apiSecret");
-    const auth = `Basic ${Buffer.from(`${apiKey}:${apiSecret}`).toString("base64")}`;
-    const client = {
-      headers: {
-        Authorization: auth,
-        "Content-Type": "application/json"
-      }
-    };
-    return client;
-  }
-  async fetchTagKeys(_subAccountConfig, _client, _query) {
-    return { tagKeys: [], provider: CLOUD_PROVIDER.CONFLUENT };
-  }
-  async fetchTagValues(_subAccountConfig, _client, _query, _tagKey) {
-    return { tagValues: [], provider: CLOUD_PROVIDER.CONFLUENT };
-  }
-  async fetchCosts(_subAccountConfig, client, query) {
-    const startDate = moment__default.default(parseInt(query.startTime, 10));
-    const endDate = moment__default.default(parseInt(query.endTime, 10));
-    const currentStartDate = startDate.clone();
-    let aggregatedData = [];
-    try {
-      while (currentStartDate.isBefore(endDate) || currentStartDate.isSame(endDate, "month")) {
-        const currentEndDate = moment__default.default.min(currentStartDate.clone().endOf("month"), endDate);
-        const url = `https://api.confluent.cloud/billing/v1/costs?start_date=${currentStartDate.format(
-          "YYYY-MM-DD"
-        )}&end_date=${currentEndDate.add("1", "d").format("YYYY-MM-DD")}`;
-        const response = await fetch(url, {
-          method: "GET",
-          headers: client.headers
-        });
-        if (!response.ok) {
-          throw new Error(`Failed to fetch costs: ${response.statusText}`);
-        }
-        const jsonResponse = await response.json();
-        const envIds = [...new Set(jsonResponse.data.map((item) => item.resource.environment.id))];
-        const envNamePromises = envIds.map((envId) => this.fetchEnvDisplayName(client, envId));
-        const envNames = await Promise.all(envNamePromises);
-        const envIdToName = {};
-        envIds.forEach((envId, index) => {
-          envIdToName[envId] = envNames[index];
-        });
-        const dataWithEnvNames = jsonResponse.data.map((item) => {
-          const envId = item.resource.environment.id;
-          return {
-            ...item,
-            envDisplayName: envIdToName[envId] || "Unknown"
-          };
-        });
-        aggregatedData = aggregatedData.concat(dataWithEnvNames);
-        currentStartDate.add(1, "month").startOf("month");
-      }
-      return {
-        data: aggregatedData
-      };
-    } catch (error) {
-      this.logger.error(`Error fetching costs from Confluent: ${error.message}`);
-      throw error;
-    }
-  }
-  async transformCostsData(subAccountConfig, query, costResponse) {
-    const categoryMappingService = CategoryMappingService.getInstance();
-    const accountName = subAccountConfig.getString("name");
-    const tags = subAccountConfig.getOptionalStringArray("tags");
-    const tagKeyValues = {};
-    tags == null ? void 0 : tags.forEach((tag) => {
-      const [k, v] = tag.split(":");
-      tagKeyValues[k.trim()] = v.trim();
-    });
-    const transformedData = costResponse.data.reduce((accumulator, line) => {
-      const amount = parseFloat(line.amount) || 0;
-      let billingPeriod = "unknown";
-      if (amount === 0) {
-        return accumulator;
-      }
-      const parsedStartDate = moment__default.default(line.start_date);
-      if (!parsedStartDate.isValid()) {
-        return accumulator;
-      }
-      if (query.granularity.toUpperCase() === "MONTHLY") {
-        billingPeriod = parsedStartDate.format("YYYY-MM");
-      } else {
-        billingPeriod = parsedStartDate.format("YYYY-MM-DD");
-      }
-      const serviceName = this.capitalizeWords(line.line_type);
-      const resourceName = line.resource.display_name || "Unknown";
-      const envDisplayName = line.envDisplayName;
-      const keyName = `${accountName}->${categoryMappingService.getCategoryByServiceName(
-        this.provider,
-        serviceName
-      )}->${resourceName}`;
-      if (!accumulator[keyName]) {
-        accumulator[keyName] = {
-          id: keyName,
-          account: `${this.provider}/${accountName}`,
-          service: this.convertServiceName(serviceName),
-          category: categoryMappingService.getCategoryByServiceName(this.provider, serviceName),
-          provider: this.provider,
-          reports: {},
-          ...{ project: envDisplayName },
-          ...{ cluster: resourceName },
-          ...tagKeyValues
-        };
-      }
-      if (!moment__default.default(billingPeriod).isBefore(moment__default.default(parseInt(query.startTime, 10)))) {
-        accumulator[keyName].reports[billingPeriod] = (accumulator[keyName].reports[billingPeriod] || 0) + amount;
-      }
-      return accumulator;
-    }, {});
-    return Object.values(transformedData);
-  }
-}
-
 class MongoAtlasClient extends InfraWalletClient {
   static create(config, database, cache, logger) {
     return new MongoAtlasClient(CLOUD_PROVIDER.MONGODB_ATLAS, config, database, cache, logger);
@@ -1376,13 +1541,7 @@ class MongoAtlasClient extends InfraWalletClient {
     const client = {
       digestAuth: `${publicKey}:${privateKey}`
     };
-    return client;
-  }
-  async fetchTagKeys(_subAccountConfig, _client, _query) {
-    return { tagKeys: [], provider: CLOUD_PROVIDER.MONGODB_ATLAS };
-  }
-  async fetchTagValues(_subAccountConfig, _client, _query, _tagKey) {
-    return { tagValues: [], provider: CLOUD_PROVIDER.MONGODB_ATLAS };
+    return client;
   }
   async fetchCosts(subAccountConfig, client, query) {
     const orgId = subAccountConfig.getString("orgId");
@@ -1446,7 +1605,7 @@ class MongoAtlasClient extends InfraWalletClient {
     const accountName = subAccountConfig.getString("name");
     const tags = subAccountConfig.getOptionalStringArray("tags");
     const tagKeyValues = {};
-    tags == null ? void 0 : tags.forEach((tag) => {
+    tags?.forEach((tag) => {
       const [k, v] = tag.split(":");
       tagKeyValues[k.trim()] = v.trim();
     });
@@ -1462,13 +1621,13 @@ class MongoAtlasClient extends InfraWalletClient {
           rowData[columnName] = columns[index];
         });
         const amount = parseFloat(rowData.Amount) || 0;
-        let billingPeriod = "unknown";
         const dateFormat = "MM/DD/YYYY";
         const date = rowData.Date;
         const parsedDate = moment__default.default(date, dateFormat, true);
         if (!parsedDate.isValid()) {
           return accumulator;
         }
+        let billingPeriod = void 0;
         if (query.granularity.toUpperCase() === "MONTHLY") {
           billingPeriod = parsedDate.format("YYYY-MM");
         } else {
@@ -1488,6 +1647,7 @@ class MongoAtlasClient extends InfraWalletClient {
             service: this.convertServiceName(serviceName),
             category: categoryMappingService.getCategoryByServiceName(this.provider, serviceName),
             provider: this.provider,
+            providerType: PROVIDER_TYPE.INTEGRATION,
             reports: {},
             ...{ project },
             ...{ cluster },
@@ -1505,12 +1665,245 @@ class MongoAtlasClient extends InfraWalletClient {
   }
 }
 
+class MetricProvider {
+  constructor(providerName, config, database, cache, logger) {
+    this.providerName = providerName;
+    this.config = config;
+    this.database = database;
+    this.cache = cache;
+    this.logger = logger;
+  }
+  async getMetrics(query) {
+    const conf = this.config.getOptionalConfigArray(
+      `backend.infraWallet.metricProviders.${this.providerName.toLowerCase()}`
+    );
+    if (!conf) {
+      return { metrics: [], errors: [] };
+    }
+    const promises = [];
+    const results = [];
+    const errors = [];
+    for (const c of conf) {
+      const configName = c.getString("name");
+      const client = await this.initProviderClient(c);
+      const dbClient = await this.database.getClient();
+      const metricSettings = await dbClient.where({
+        "wallets.name": query.walletName,
+        "business_metrics.metric_provider": this.providerName.toLowerCase(),
+        "business_metrics.config_name": configName
+      }).select("business_metrics.*").from("business_metrics").join("wallets", "business_metrics.wallet_id", "=", "wallets.id");
+      for (const metric of metricSettings || []) {
+        const promise = (async () => {
+          try {
+            const fullQuery = {
+              name: metric.metric_name,
+              query: metric.query,
+              ...query
+            };
+            const cachedMetrics = await getMetricsFromCache(this.cache, this.providerName, configName, fullQuery);
+            if (cachedMetrics) {
+              this.logger.debug(`${this.providerName}/${configName}/${fullQuery.name} metrics from cache`);
+              cachedMetrics.forEach((m) => {
+                results.push({
+                  group: metric.group,
+                  // add group info to the metric
+                  ...m
+                });
+              });
+              return;
+            }
+            const metricResponse = await this.fetchMetrics(c, client, fullQuery);
+            const transformedMetrics = await this.transformMetricData(c, fullQuery, metricResponse);
+            await setMetricsToCache(
+              this.cache,
+              transformedMetrics,
+              this.providerName,
+              configName,
+              fullQuery,
+              60 * 60 * 2 * 1e3
+            );
+            transformedMetrics.forEach((value) => {
+              results.push({
+                group: metric.group,
+                // add group info to the metric
+                ...value
+              });
+            });
+          } catch (e) {
+            this.logger.error(e);
+            errors.push({
+              provider: this.providerName,
+              name: `${this.providerName}/${configName}/${metric.getString("metricName")}`,
+              error: e.message
+            });
+          }
+        })();
+        promises.push(promise);
+      }
+    }
+    await Promise.all(promises);
+    return {
+      metrics: results,
+      errors
+    };
+  }
+}
+
+class DatadogProvider extends MetricProvider {
+  static create(config, database, cache, logger) {
+    return new DatadogProvider("Datadog", config, database, cache, logger);
+  }
+  async initProviderClient(config) {
+    const apiKey = config.getString("apiKey");
+    const applicationKey = config.getString("applicationKey");
+    const ddSite = config.getString("ddSite");
+    const configuration = datadogApiClient.client.createConfiguration({
+      baseServer: new datadogApiClient.client.BaseServerConfiguration(ddSite, {}),
+      authMethods: {
+        apiKeyAuth: apiKey,
+        appKeyAuth: applicationKey
+      }
+    });
+    const client = new datadogApiClient.v1.MetricsApi(configuration);
+    return client;
+  }
+  async fetchMetrics(_metricProviderConfig, client, query) {
+    const params = {
+      from: parseInt(query.startTime, 10) / 1e3,
+      to: parseInt(query.endTime, 10) / 1e3,
+      query: query.query?.replaceAll("IW_INTERVAL", query.granularity === "daily" ? "86400" : "2592000")
+    };
+    return client.queryMetrics(params).then((data) => {
+      if (data.status === "ok") {
+        return data;
+      }
+      throw new Error(data.error);
+    });
+  }
+  async transformMetricData(_metricProviderConfig, query, metricResponse) {
+    const transformedData = [];
+    for (const series of metricResponse.series) {
+      const metricName = query.name;
+      const tagSet = series.tagSet;
+      const metric = {
+        id: `${metricName} ${tagSet.length === 0 ? "" : tagSet}`,
+        provider: this.providerName,
+        name: metricName,
+        reports: {}
+      };
+      for (const point of series.pointlist) {
+        const period = moment__default.default(point[0]).format(query.granularity === "daily" ? "YYYY-MM-DD" : "YYYY-MM");
+        const value = point[1];
+        metric.reports[period] = value;
+      }
+      transformedData.push(metric);
+    }
+    return transformedData;
+  }
+}
+
+class GrafanaCloudProvider extends MetricProvider {
+  static create(config, database, cache, logger) {
+    return new GrafanaCloudProvider("GrafanaCloud", config, database, cache, logger);
+  }
+  async initProviderClient(_config) {
+    return null;
+  }
+  async fetchMetrics(metricProviderConfig, _client, query) {
+    const url = metricProviderConfig.getString("url");
+    const datasourceUid = metricProviderConfig.getString("datasourceUid");
+    const token = metricProviderConfig.getString("token");
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    };
+    const payload = {
+      queries: [
+        {
+          datasource: {
+            uid: datasourceUid
+          },
+          expr: query.query?.replaceAll("IW_INTERVAL", query.granularity === "daily" ? "1d" : "30d"),
+          refId: "A"
+        }
+      ],
+      from: query.startTime,
+      to: query.endTime
+    };
+    const response = await fetch__default.default(`${url}/api/ds/query`, {
+      method: "post",
+      body: JSON.stringify(payload),
+      headers
+    });
+    const data = await response.json();
+    return data;
+  }
+  async transformMetricData(_metricProviderConfig, query, metricResponse) {
+    const transformedData = [];
+    const metricName = query.name;
+    const metric = {
+      id: metricName,
+      provider: this.providerName,
+      name: metricName,
+      reports: {}
+    };
+    const periods = metricResponse.results.A.frames[0].data.values[0];
+    const values = metricResponse.results.A.frames[0].data.values[1];
+    for (let i = 0; i < periods.length; i++) {
+      const period = moment__default.default(periods[i]).format(query.granularity === "daily" ? "YYYY-MM-DD" : "YYYY-MM");
+      const value = values[i];
+      metric.reports[period] = value;
+    }
+    transformedData.push(metric);
+    return transformedData;
+  }
+}
+
+class MockProvider extends MetricProvider {
+  static create(config, database, cache, logger) {
+    return new MockProvider("Mock", config, database, cache, logger);
+  }
+  async initProviderClient(_config) {
+    return null;
+  }
+  async fetchMetrics(_metricProviderConfig, _client, _query) {
+    return null;
+  }
+  async transformMetricData(_metricProviderConfig, query, _metricResponse) {
+    const transformedData = [];
+    const metricName = query.name;
+    let mockSettings = {};
+    try {
+      mockSettings = JSON.parse(query.query);
+    } catch (e) {
+    }
+    const minValue = mockSettings.min ?? 0;
+    const maxValue = mockSettings.max ?? 1e3;
+    const metric = {
+      id: metricName,
+      provider: this.providerName,
+      name: metricName,
+      reports: {}
+    };
+    let cursor = moment__default.default(parseInt(query.startTime, 10));
+    while (cursor <= moment__default.default(parseInt(query.endTime, 10))) {
+      const period = cursor.format(query.granularity === "daily" ? "YYYY-MM-DD" : "YYYY-MM");
+      metric.reports[period] = Math.floor(Math.random() * (maxValue - minValue) + minValue);
+      cursor = cursor.add(1, query.granularity === "daily" ? "days" : "months");
+    }
+    transformedData.push(metric);
+    return transformedData;
+  }
+}
+
 var CLOUD_PROVIDER = /* @__PURE__ */ ((CLOUD_PROVIDER2) => {
   CLOUD_PROVIDER2["AWS"] = "AWS";
   CLOUD_PROVIDER2["GCP"] = "GCP";
   CLOUD_PROVIDER2["AZURE"] = "Azure";
   CLOUD_PROVIDER2["MONGODB_ATLAS"] = "MongoAtlas";
   CLOUD_PROVIDER2["CONFLUENT"] = "Confluent";
+  CLOUD_PROVIDER2["DATADOG"] = "Datadog";
+  CLOUD_PROVIDER2["CUSTOM"] = "Custom";
   CLOUD_PROVIDER2["MOCK"] = "Mock";
   return CLOUD_PROVIDER2;
 })(CLOUD_PROVIDER || {});
@@ -1520,6 +1913,8 @@ const COST_CLIENT_MAPPINGS = {
   gcp: GCPClient,
   confluent: ConfluentClient,
   mongoatlas: MongoAtlasClient,
+  datadog: DatadogClient,
+  custom: CustomProviderClient,
   mock: MockClient
 };
 const METRIC_PROVIDER_MAPPINGS = {
@@ -1527,6 +1922,11 @@ const METRIC_PROVIDER_MAPPINGS = {
   grafanacloud: GrafanaCloudProvider,
   mock: MockProvider
 };
+var GRANULARITY = /* @__PURE__ */ ((GRANULARITY2) => {
+  GRANULARITY2["DAILY"] = "daily";
+  GRANULARITY2["MONTHLY"] = "monthly";
+  return GRANULARITY2;
+})(GRANULARITY || {});
 var CACHE_CATEGORY = /* @__PURE__ */ ((CACHE_CATEGORY2) => {
   CACHE_CATEGORY2["COSTS"] = "costs";
   CACHE_CATEGORY2["TAGS"] = "tags";
@@ -1542,7 +1942,10 @@ const DEFAULT_TAGS_CACHE_TTL = {
   ["GCP" /* GCP */]: 1 * 60 * 60 * 1e3,
   ["MongoAtlas" /* MONGODB_ATLAS */]: 1 * 60 * 60 * 1e3,
   ["Confluent" /* CONFLUENT */]: 1 * 60 * 60 * 1e3,
+  ["Datadog" /* DATADOG */]: 1 * 60 * 60 * 1e3,
+  ["Custom" /* CUSTOM */]: 1,
   ["Mock" /* MOCK */]: 0
+  // NOTE: 0 means never expired!
 };
 const DEFAULT_COSTS_CACHE_TTL = {
   ["AWS" /* AWS */]: 2 * 60 * 60 * 1e3,
@@ -1551,33 +1954,37 @@ const DEFAULT_COSTS_CACHE_TTL = {
   ["GCP" /* GCP */]: 2 * 60 * 60 * 1e3,
   ["MongoAtlas" /* MONGODB_ATLAS */]: 2 * 60 * 60 * 1e3,
   ["Confluent" /* CONFLUENT */]: 2 * 60 * 60 * 1e3,
+  ["Datadog" /* DATADOG */]: 2 * 60 * 60 * 1e3,
+  ["Custom" /* CUSTOM */]: 1,
+  // do not cache custom costs since they are in the plugin database
   ["Mock" /* MOCK */]: 0
+  // NOTE: 0 means never expired!
 };
+var PROVIDER_TYPE = /* @__PURE__ */ ((PROVIDER_TYPE2) => {
+  PROVIDER_TYPE2["INTEGRATION"] = "Integration";
+  PROVIDER_TYPE2["CUSTOM"] = "Custom";
+  return PROVIDER_TYPE2;
+})(PROVIDER_TYPE || {});
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-const _CategoryMappingService = class _CategoryMappingService {
+class CategoryMappingService {
   constructor(cache, logger) {
     this.cache = cache;
     this.logger = logger;
-    __publicField(this, "categoryMappings", {});
-    __publicField(this, "serviceToCategory", {});
   }
+  static instance;
   static initInstance(cache, logger) {
-    if (!_CategoryMappingService.instance) {
-      _CategoryMappingService.instance = new _CategoryMappingService(cache, logger);
+    if (!CategoryMappingService.instance) {
+      CategoryMappingService.instance = new CategoryMappingService(cache, logger);
     }
   }
   static getInstance() {
-    if (!_CategoryMappingService.instance) {
+    if (!CategoryMappingService.instance) {
       throw new Error("CategoryMappingService needs to be initialized first");
     }
-    return _CategoryMappingService.instance;
+    return CategoryMappingService.instance;
   }
+  categoryMappings = {};
+  serviceToCategory = {};
   generateServiceToCategoryMappings(categoryMappings) {
     const result = {};
     for (const [category, mappings] of Object.entries(categoryMappings)) {
@@ -1641,15 +2048,12 @@ const _CategoryMappingService = class _CategoryMappingService {
     this.logger.debug(`serviceToCategoryMappings updated: ${providerLowerCase}/${serviceName} -> ${result}`);
     return result;
   }
-};
-__publicField(_CategoryMappingService, "instance");
-let CategoryMappingService = _CategoryMappingService;
+}
 
 async function setUpDatabase(database) {
-  var _a;
   const client = await database.getClient();
   const migrationsDir = backendPluginApi.resolvePackagePath("@electrolux-oss/plugin-infrawallet-backend", "migrations");
-  if (!((_a = database.migrations) == null ? void 0 : _a.skip)) {
+  if (!database.migrations?.skip) {
     await client.migrate.latest({
       directory: migrationsDir
     });
@@ -1688,7 +2092,7 @@ async function createRouter(options) {
     const categoryMappingService = CategoryMappingService.getInstance();
     await categoryMappingService.refreshCategoryMappings();
     const conf = config.getConfig("backend.infraWallet.integrations");
-    conf.keys().forEach((provider) => {
+    conf.keys().concat(["custom"]).forEach((provider) => {
       if (provider in COST_CLIENT_MAPPINGS) {
         const client = COST_CLIENT_MAPPINGS[provider].create(config, database, cache, logger);
         const fetchCloudCosts = (async () => {
@@ -1824,6 +2228,62 @@ async function createRouter(options) {
       response.json({ data: tags, errors, status: 200 });
     }
   });
+  router.get("/:walletName/budgets", async (request, response) => {
+    const walletName = request.params.walletName;
+    const provider = request.query.provider;
+    let budgets;
+    if (provider) {
+      budgets = await getBudget(database, walletName, provider);
+    } else {
+      budgets = await getBudgets(database, walletName);
+    }
+    response.json({ data: budgets, status: 200 });
+  });
+  router.put("/:walletName/budgets", async (request, response) => {
+    const walletName = request.params.walletName;
+    const result = await upsertBudget(database, walletName, request.body);
+    response.json({ updated: result, status: 200 });
+  });
+  router.get("/custom-costs", async (_request, response) => {
+    const customCosts = await getCustomCosts(database);
+    for (const cost of customCosts) {
+      if (typeof cost.tags === "string") {
+        try {
+          cost.tags = JSON.parse(cost.tags);
+        } catch (error) {
+          cost.tags = {};
+        }
+      }
+    }
+    response.json({ data: customCosts, status: 200 });
+  });
+  router.post("/custom-costs", async (request, response) => {
+    const readOnly = config.getOptionalBoolean("infraWallet.settings.readOnly") ?? false;
+    if (readOnly) {
+      response.status(403).json({ error: "API not enabled in read-only mode", status: 403 });
+      return;
+    }
+    const updatedCustomCost = await createCustomCosts(database, request.body);
+    response.json({ created: updatedCustomCost, status: 200 });
+  });
+  router.put("/custom-cost", async (request, response) => {
+    const readOnly = config.getOptionalBoolean("infraWallet.settings.readOnly") ?? false;
+    if (readOnly) {
+      response.status(403).json({ error: "API not enabled in read-only mode", status: 403 });
+      return;
+    }
+    const updatedCustomCost = await updateOrInsertCustomCost(database, request.body);
+    response.json({ updated: updatedCustomCost, status: 200 });
+  });
+  router.delete("/custom-cost", async (request, response) => {
+    const readOnly = config.getOptionalBoolean("infraWallet.settings.readOnly") ?? false;
+    if (readOnly) {
+      response.status(403).json({ error: "API not enabled in read-only mode", status: 403 });
+      return;
+    }
+    const deletedCustomCost = await deleteCustomCost(database, request.body);
+    response.json({ deleted: deletedCustomCost, status: 200 });
+  });
   router.get("/:walletName/metrics", async (request, response) => {
     const walletName = request.params.walletName;
     const granularity = request.query.granularity;
@@ -1878,12 +2338,12 @@ async function createRouter(options) {
     }
     response.json({ data: wallet, status: 200 });
   });
-  router.get("/:walletName/metrics_setting", async (request, response) => {
+  router.get("/:walletName/metrics-setting", async (request, response) => {
     const walletName = request.params.walletName;
     const metricSettings = await getWalletMetricSettings(database, walletName);
     response.json({ data: metricSettings, status: 200 });
   });
-  router.get("/metric/metric_configs", async (_request, response) => {
+  router.get("/metric/metric-configs", async (_request, response) => {
     const conf = config.getConfig("backend.infraWallet.metricProviders");
     const configNames = [];
     conf.keys().forEach((provider) => {
@@ -1896,9 +2356,8 @@ async function createRouter(options) {
     });
     response.json({ data: configNames, status: 200 });
   });
-  router.put("/:walletName/metrics_setting", async (request, response) => {
-    var _a;
-    const readOnly = (_a = config.getOptionalBoolean("infraWallet.settings.readOnly")) != null ? _a : false;
+  router.put("/:walletName/metrics-setting", async (request, response) => {
+    const readOnly = config.getOptionalBoolean("infraWallet.settings.readOnly") ?? false;
     if (readOnly) {
       response.status(403).json({ error: "API not enabled in read-only mode", status: 403 });
       return;
@@ -1906,9 +2365,8 @@ async function createRouter(options) {
     const updatedMetricSetting = await updateOrInsertWalletMetricSetting(database, request.body);
     response.json({ updated: updatedMetricSetting, status: 200 });
   });
-  router.delete("/:walletName/metrics_setting", async (request, response) => {
-    var _a;
-    const readOnly = (_a = config.getOptionalBoolean("infraWallet.settings.readOnly")) != null ? _a : false;
+  router.delete("/:walletName/metrics-setting", async (request, response) => {
+    const readOnly = config.getOptionalBoolean("infraWallet.settings.readOnly") ?? false;
     if (readOnly) {
       response.status(403).json({ error: "API not enabled in read-only mode", status: 403 });
       return;