@robhan-cdk-lib/aws_aps 0.0.0

package/lib/validation/workspace-base.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateLoggingConfiguration = validateLoggingConfiguration;
+exports.validateCloudWatchLogDestination = validateCloudWatchLogDestination;
+exports.validateLoggingFilter = validateLoggingFilter;
+exports.validateLoggingDestination = validateLoggingDestination;
+exports.validateQueryLoggingConfiguration = validateQueryLoggingConfiguration;
+exports.validateLimitsPerLabelSetEntry = validateLimitsPerLabelSetEntry;
+exports.validateLabel = validateLabel;
+exports.validateLimitsPerLabelSet = validateLimitsPerLabelSet;
+exports.validateWorkspaceConfiguration = validateWorkspaceConfiguration;
+exports.validateAlertManagerDefinition = validateAlertManagerDefinition;
+exports.validateAlias = validateAlias;
+const utils_1 = require("@robhan-cdk-lib/utils");
+function validateLoggingConfiguration(loggingConfiguration) {
+    const errors = [];
+    if (typeof loggingConfiguration !== 'object') {
+        errors.push('must be an object');
+        return errors; // No need to check further if not an object
+    }
+    const loggingConfigurationObject = loggingConfiguration;
+    errors.push(...(0, utils_1.validateObjectAttributes)({
+        inputObject: loggingConfigurationObject,
+        mandatoryAttributes: [],
+        optionalAttributes: ['logGroup'],
+    }));
+    return errors;
+}
+function validateCloudWatchLogDestination(cloudWatchLogDestination) {
+    const errors = [];
+    if (typeof cloudWatchLogDestination !== 'object') {
+        errors.push('must be an object');
+        return errors; // No need to check further if not an object
+    }
+    const cloudWatchLogDestinationObject = cloudWatchLogDestination;
+    errors.push(...(0, utils_1.validateObjectAttributes)({
+        inputObject: cloudWatchLogDestinationObject,
+        mandatoryAttributes: ['logGroup'],
+        optionalAttributes: [],
+    }));
+    return errors;
+}
+function validateLoggingFilter(loggingFilter) {
+    const errors = [];
+    if (typeof loggingFilter !== 'object') {
+        errors.push('must be an object');
+        return errors; // No need to check further if not an object
+    }
+    const loggingFilterObject = loggingFilter;
+    errors.push(...(0, utils_1.validateObjectAttributes)({
+        inputObject: loggingFilterObject,
+        mandatoryAttributes: ['qspThreshold'],
+        optionalAttributes: [],
+    }));
+    if (loggingFilterObject.qspThreshold !== undefined) {
+        if (typeof loggingFilterObject.qspThreshold !== 'number') {
+            errors.push('qspThreshold: must be a number');
+        }
+        else {
+            errors.push(...(0, utils_1.validateNumberRange)({
+                value: loggingFilterObject.qspThreshold,
+                min: 0,
+                messagePrefix: 'qspThreshold: ',
+            }));
+        }
+    }
+    return errors;
+}
+function validateLoggingDestination(loggingDestination) {
+    const errors = [];
+    if (typeof loggingDestination !== 'object') {
+        errors.push('must be an object');
+        return errors; // No need to check further if not an object
+    }
+    const loggingDestinationObject = loggingDestination;
+    errors.push(...(0, utils_1.validateObjectAttributes)({
+        inputObject: loggingDestinationObject,
+        mandatoryAttributes: ['cloudWatchLogs', 'filters'],
+        optionalAttributes: [],
+    }));
+    if (loggingDestinationObject.cloudWatchLogs !== undefined) {
+        errors.push(...validateCloudWatchLogDestination(loggingDestinationObject.cloudWatchLogs).map((err) => `cloudWatchLogs: ${err}`));
+    }
+    if (loggingDestinationObject.filters !== undefined) {
+        errors.push(...validateLoggingFilter(loggingDestinationObject.filters).map((err) => `filters: ${err}`));
+    }
+    return errors;
+}
+function validateQueryLoggingConfiguration(queryLoggingConfiguration) {
+    const errors = [];
+    if (typeof queryLoggingConfiguration !== 'object') {
+        errors.push('must be an object');
+        return errors; // No need to check further if not an object
+    }
+    const queryLoggingConfigurationObject = queryLoggingConfiguration;
+    errors.push(...(0, utils_1.validateObjectAttributes)({
+        inputObject: queryLoggingConfigurationObject,
+        mandatoryAttributes: ['destinations'],
+        optionalAttributes: [],
+    }));
+    if (queryLoggingConfigurationObject.destinations !== undefined) {
+        errors.push(...queryLoggingConfigurationObject.destinations.map((d, i) => {
+            return validateLoggingDestination(d).map((err) => `destinations[${i}]: ${err}`);
+        }).flat());
+    }
+    return errors;
+}
+function validateLimitsPerLabelSetEntry(limitsPerLabelSetEntry) {
+    const errors = [];
+    if (typeof limitsPerLabelSetEntry !== 'object') {
+        errors.push('must be an object');
+        return errors; // No need to check further if not an object
+    }
+    const limitsPerLabelSetEntryObject = limitsPerLabelSetEntry;
+    errors.push(...(0, utils_1.validateObjectAttributes)({
+        inputObject: limitsPerLabelSetEntryObject,
+        mandatoryAttributes: [],
+        optionalAttributes: ['maxSeries'],
+    }));
+    if (limitsPerLabelSetEntryObject.maxSeries !== undefined) {
+        if (typeof limitsPerLabelSetEntryObject.maxSeries !== 'number') {
+            errors.push('maxSeries: must be a number');
+        }
+        else {
+            errors.push(...(0, utils_1.validateNumberRange)({
+                value: limitsPerLabelSetEntryObject.maxSeries,
+                min: 0,
+                messagePrefix: 'maxSeries: ',
+            }));
+        }
+    }
+    return errors;
+}
+function validateLabel(label) {
+    const errors = [];
+    if (typeof label !== 'object') {
+        errors.push('must be an object');
+        return errors; // No need to check further if not an object
+    }
+    const labelObject = label;
+    errors.push(...(0, utils_1.validateObjectAttributes)({
+        inputObject: labelObject,
+        mandatoryAttributes: ['name', 'value'],
+        optionalAttributes: [],
+    }));
+    if (labelObject.name !== undefined) {
+        if (typeof labelObject.name !== 'string') {
+            errors.push('name: must be a string');
+        }
+        else {
+            errors.push(...(0, utils_1.validateRegExp)({
+                regExp: /^[a-zA-Z_][a-zA-Z0-9_]*$/,
+                value: labelObject.name,
+                messagePrefix: 'name: ',
+            }));
+            errors.push(...(0, utils_1.validateStringLength)({
+                value: labelObject.name,
+                min: 1,
+            }));
+        }
+    }
+    if (labelObject.value !== undefined) {
+        if (typeof labelObject.value !== 'string') {
+            errors.push('value: must be a string');
+        }
+        else {
+            errors.push(...(0, utils_1.validateStringLength)({
+                value: labelObject.value,
+                min: 1,
+                messagePrefix: 'value: ',
+            }));
+        }
+    }
+    return errors;
+}
+function validateLimitsPerLabelSet(limitsPerLabelSet) {
+    const errors = [];
+    if (typeof limitsPerLabelSet !== 'object') {
+        errors.push('must be an object');
+        return errors; // No need to check further if not an object
+    }
+    const limitsPerLabelSetObject = limitsPerLabelSet;
+    errors.push(...(0, utils_1.validateObjectAttributes)({
+        inputObject: limitsPerLabelSetObject,
+        mandatoryAttributes: ['labelSet', 'limits'],
+        optionalAttributes: [],
+    }));
+    if (limitsPerLabelSetObject.labelSet !== undefined) {
+        errors.push(...limitsPerLabelSetObject.labelSet.map((l, i) => {
+            return validateLabel(l).map((err) => `labelSet[${i}]: ${err}`);
+        }).flat());
+    }
+    if (limitsPerLabelSetObject.limits !== undefined) {
+        errors.push(...validateLimitsPerLabelSetEntry(limitsPerLabelSetObject.limits).map((err) => `limits: ${err}`));
+    }
+    return errors;
+}
+function validateWorkspaceConfiguration(workspaceConfiguration) {
+    const errors = [];
+    if (typeof workspaceConfiguration !== 'object') {
+        errors.push('must be an object');
+        return errors; // No need to check further if not an object
+    }
+    const workspaceConfigurationObject = workspaceConfiguration;
+    errors.push(...(0, utils_1.validateObjectAttributes)({
+        inputObject: workspaceConfigurationObject,
+        mandatoryAttributes: [],
+        optionalAttributes: ['limitsPerLabelSets', 'retentionPeriodInDays'],
+    }));
+    if (workspaceConfigurationObject.limitsPerLabelSets !== undefined) {
+        if (!Array.isArray(workspaceConfigurationObject.limitsPerLabelSets)) {
+            errors.push('limitsPerLabelSets: must be an array');
+        }
+        else {
+            errors.push(...(0, utils_1.validateArrayLength)({
+                value: workspaceConfigurationObject.limitsPerLabelSets,
+                min: 0,
+                messagePrefix: 'limitsPerLabelSets: ',
+            }));
+            errors.push(...workspaceConfigurationObject.limitsPerLabelSets.map((l, i) => {
+                return validateLimitsPerLabelSet(l).map((err) => `limitsPerLabelSets[${i}]: ${err}`);
+            }).flat());
+        }
+    }
+    if (workspaceConfigurationObject.retentionPeriodInDays !== undefined) {
+        if (typeof workspaceConfigurationObject.retentionPeriodInDays !== 'number') {
+            errors.push('retentionPeriodInDays: must be a number');
+        }
+        else {
+            errors.push(...(0, utils_1.validateNumberRange)({
+                value: workspaceConfigurationObject.retentionPeriodInDays,
+                min: 1,
+                messagePrefix: 'retentionPeriodInDays: ',
+            }));
+        }
+    }
+    return errors;
+}
+function validateAlertManagerDefinition(alertManagerDefinition) {
+    const errors = [];
+    if (typeof alertManagerDefinition !== 'string') {
+        errors.push('must be a string');
+        return errors; // No need to check further if not a string
+    }
+    return errors;
+}
+function validateAlias(alias) {
+    const errors = [];
+    if (typeof alias !== 'string') {
+        errors.push('must be a string');
+        return errors; // No need to check further if not a string
+    }
+    errors.push(...(0, utils_1.validateStringLength)({
+        value: alias,
+        min: 0,
+        max: 100,
+    }));
+    return errors;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspace-base.js","sourceRoot":"","sources":["../../src/validation/workspace-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { validateArrayLength, validateNumberRange, validateObjectAttributes, validateRegExp, validateStringLength } from '@robhan-cdk-lib/utils';\nimport {\n  CloudWatchLogDestination,\n  LoggingConfiguration,\n  LoggingFilter,\n  LoggingDestination,\n  QueryLoggingConfiguration,\n  LimitsPerLabelSetEntry,\n  Label,\n  LimitsPerLabelSet,\n  WorkspaceConfiguration,\n} from '../workspace-base';\n\nexport function validateLoggingConfiguration(loggingConfiguration: unknown): string[] {\n  const errors: string[] = [];\n\n  if (typeof loggingConfiguration !== 'object') {\n    errors.push('must be an object');\n    return errors; // No need to check further if not an object\n  }\n\n  const loggingConfigurationObject = loggingConfiguration as LoggingConfiguration;\n  errors.push(...validateObjectAttributes({\n    inputObject: loggingConfigurationObject,\n    mandatoryAttributes: [],\n    optionalAttributes: ['logGroup'],\n  }));\n\n  return errors;\n}\n\nexport function validateCloudWatchLogDestination(cloudWatchLogDestination: unknown): string[] {\n  const errors: string[] = [];\n\n  if (typeof cloudWatchLogDestination !== 'object') {\n    errors.push('must be an object');\n    return errors; // No need to check further if not an object\n  }\n\n  const cloudWatchLogDestinationObject = cloudWatchLogDestination as CloudWatchLogDestination;\n  errors.push(...validateObjectAttributes({\n    inputObject: cloudWatchLogDestinationObject,\n    mandatoryAttributes: ['logGroup'],\n    optionalAttributes: [],\n  }));\n\n  return errors;\n}\n\nexport function validateLoggingFilter(loggingFilter: unknown): string[] {\n  const errors: string[] = [];\n\n  if (typeof loggingFilter !== 'object') {\n    errors.push('must be an object');\n    return errors; // No need to check further if not an object\n  }\n\n  const loggingFilterObject = loggingFilter as LoggingFilter;\n  errors.push(...validateObjectAttributes({\n    inputObject: loggingFilterObject,\n    mandatoryAttributes: ['qspThreshold'],\n    optionalAttributes: [],\n  }));\n\n  if (loggingFilterObject.qspThreshold !== undefined) {\n\n    if (typeof loggingFilterObject.qspThreshold !== 'number') {\n      errors.push('qspThreshold: must be a number');\n    } else {\n      errors.push(...validateNumberRange({\n        value: loggingFilterObject.qspThreshold,\n        min: 0,\n        messagePrefix: 'qspThreshold: ',\n      }));\n    }\n  }\n\n  return errors;\n}\n\nexport function validateLoggingDestination(loggingDestination: unknown): string[] {\n  const errors: string[] = [];\n\n  if (typeof loggingDestination !== 'object') {\n    errors.push('must be an object');\n    return errors; // No need to check further if not an object\n  }\n\n  const loggingDestinationObject = loggingDestination as LoggingDestination;\n  errors.push(...validateObjectAttributes({\n    inputObject: loggingDestinationObject,\n    mandatoryAttributes: ['cloudWatchLogs', 'filters'],\n    optionalAttributes: [],\n  }));\n\n  if (loggingDestinationObject.cloudWatchLogs !== undefined) {\n    errors.push(...validateCloudWatchLogDestination(loggingDestinationObject.cloudWatchLogs).map((err) => `cloudWatchLogs: ${err}`));\n  }\n\n  if (loggingDestinationObject.filters !== undefined) {\n    errors.push(...validateLoggingFilter(loggingDestinationObject.filters).map((err) => `filters: ${err}`));\n  }\n\n  return errors;\n}\n\nexport function validateQueryLoggingConfiguration(queryLoggingConfiguration: unknown): string[] {\n  const errors: string[] = [];\n\n  if (typeof queryLoggingConfiguration !== 'object') {\n    errors.push('must be an object');\n    return errors; // No need to check further if not an object\n  }\n\n  const queryLoggingConfigurationObject = queryLoggingConfiguration as QueryLoggingConfiguration;\n  errors.push(...validateObjectAttributes({\n    inputObject: queryLoggingConfigurationObject,\n    mandatoryAttributes: ['destinations'],\n    optionalAttributes: [],\n  }));\n\n  if (queryLoggingConfigurationObject.destinations !== undefined) {\n    errors.push(...queryLoggingConfigurationObject.destinations.map((d, i) => {\n      return validateLoggingDestination(d).map((err) => `destinations[${i}]: ${err}`);\n    }).flat());\n  }\n\n  return errors;\n}\n\nexport function validateLimitsPerLabelSetEntry(limitsPerLabelSetEntry: unknown): string[] {\n  const errors: string[] = [];\n\n  if (typeof limitsPerLabelSetEntry !== 'object') {\n    errors.push('must be an object');\n    return errors; // No need to check further if not an object\n  }\n\n  const limitsPerLabelSetEntryObject = limitsPerLabelSetEntry as LimitsPerLabelSetEntry;\n  errors.push(...validateObjectAttributes({\n    inputObject: limitsPerLabelSetEntryObject,\n    mandatoryAttributes: [],\n    optionalAttributes: ['maxSeries'],\n  }));\n\n  if (limitsPerLabelSetEntryObject.maxSeries !== undefined) {\n    if (typeof limitsPerLabelSetEntryObject.maxSeries !== 'number') {\n      errors.push('maxSeries: must be a number');\n    } else {\n      errors.push(...validateNumberRange({\n        value: limitsPerLabelSetEntryObject.maxSeries,\n        min: 0,\n        messagePrefix: 'maxSeries: ',\n      }));\n    }\n  }\n\n  return errors;\n}\n\nexport function validateLabel(label: unknown): string[] {\n  const errors: string[] = [];\n\n  if (typeof label !== 'object') {\n    errors.push('must be an object');\n    return errors; // No need to check further if not an object\n  }\n\n  const labelObject = label as Label;\n  errors.push(...validateObjectAttributes({\n    inputObject: labelObject,\n    mandatoryAttributes: ['name', 'value'],\n    optionalAttributes: [],\n  }));\n\n  if (labelObject.name !== undefined) {\n\n    if (typeof labelObject.name !== 'string') {\n      errors.push('name: must be a string');\n    } else {\n      errors.push(...validateRegExp({\n        regExp: /^[a-zA-Z_][a-zA-Z0-9_]*$/,\n        value: labelObject.name,\n        messagePrefix: 'name: ',\n      }));\n      errors.push(...validateStringLength({\n        value: labelObject.name,\n        min: 1,\n      }));\n    }\n  }\n\n  if (labelObject.value !== undefined) {\n    if (typeof labelObject.value !== 'string') {\n      errors.push('value: must be a string');\n    } else {\n      errors.push(...validateStringLength({\n        value: labelObject.value,\n        min: 1,\n        messagePrefix: 'value: ',\n      }));\n    }\n  }\n\n  return errors;\n}\n\nexport function validateLimitsPerLabelSet(limitsPerLabelSet: unknown): string[] {\n  const errors: string[] = [];\n\n  if (typeof limitsPerLabelSet !== 'object') {\n    errors.push('must be an object');\n    return errors; // No need to check further if not an object\n  }\n\n  const limitsPerLabelSetObject = limitsPerLabelSet as LimitsPerLabelSet;\n  errors.push(...validateObjectAttributes({\n    inputObject: limitsPerLabelSetObject,\n    mandatoryAttributes: ['labelSet', 'limits'],\n    optionalAttributes: [],\n  }));\n\n  if (limitsPerLabelSetObject.labelSet !== undefined) {\n    errors.push(...limitsPerLabelSetObject.labelSet.map((l, i) => {\n      return validateLabel(l).map((err) => `labelSet[${i}]: ${err}`);\n    }).flat());\n  }\n\n  if (limitsPerLabelSetObject.limits !== undefined) {\n    errors.push(...validateLimitsPerLabelSetEntry(limitsPerLabelSetObject.limits).map((err) => `limits: ${err}`));\n  }\n\n  return errors;\n}\n\nexport function validateWorkspaceConfiguration(workspaceConfiguration: unknown): string[] {\n  const errors: string[] = [];\n\n  if (typeof workspaceConfiguration !== 'object') {\n    errors.push('must be an object');\n    return errors; // No need to check further if not an object\n  }\n\n  const workspaceConfigurationObject = workspaceConfiguration as WorkspaceConfiguration;\n  errors.push(...validateObjectAttributes({\n    inputObject: workspaceConfigurationObject,\n    mandatoryAttributes: [],\n    optionalAttributes: ['limitsPerLabelSets', 'retentionPeriodInDays'],\n  }));\n\n  if (workspaceConfigurationObject.limitsPerLabelSets !== undefined) {\n\n    if (!Array.isArray(workspaceConfigurationObject.limitsPerLabelSets)) {\n      errors.push('limitsPerLabelSets: must be an array');\n    } else {\n      errors.push(...validateArrayLength({\n        value: workspaceConfigurationObject.limitsPerLabelSets,\n        min: 0,\n        messagePrefix: 'limitsPerLabelSets: ',\n      }));\n      errors.push(...workspaceConfigurationObject.limitsPerLabelSets.map((l, i) => {\n        return validateLimitsPerLabelSet(l).map((err) => `limitsPerLabelSets[${i}]: ${err}`);\n      }).flat());\n    }\n  }\n\n  if (workspaceConfigurationObject.retentionPeriodInDays !== undefined) {\n    if (typeof workspaceConfigurationObject.retentionPeriodInDays !== 'number') {\n      errors.push('retentionPeriodInDays: must be a number');\n    } else {\n      errors.push(...validateNumberRange({\n        value: workspaceConfigurationObject.retentionPeriodInDays,\n        min: 1,\n        messagePrefix: 'retentionPeriodInDays: ',\n      }));\n    }\n  }\n\n  return errors;\n}\n\nexport function validateAlertManagerDefinition(alertManagerDefinition: unknown): string[] {\n  const errors: string[] = [];\n\n  if (typeof alertManagerDefinition !== 'string') {\n    errors.push('must be a string');\n    return errors; // No need to check further if not a string\n  }\n  return errors;\n}\n\nexport function validateAlias(alias: unknown): string[] {\n  const errors: string[] = [];\n\n  if (typeof alias !== 'string') {\n    errors.push('must be a string');\n    return errors; // No need to check further if not a string\n  }\n\n  errors.push(...validateStringLength({\n    value: alias,\n    min: 0,\n    max: 100,\n  }));\n  return errors;\n}"]}

package/lib/workspace-base.d.ts

@@ -0,0 +1,217 @@
+import { IResource, Resource } from 'aws-cdk-lib';
+import { IKey } from 'aws-cdk-lib/aws-kms';
+import { ILogGroup } from 'aws-cdk-lib/aws-logs';
+/**
+ * Contains information about the rules and alerting logging configuration for the workspace.
+ */
+export interface LoggingConfiguration {
+    /**
+     * The CloudWatch log group to which the vended log data will be published.
+     */
+    readonly logGroup?: ILogGroup;
+}
+/**
+ * Configuration details for logging to CloudWatch Logs.
+ */
+export interface CloudWatchLogDestination {
+    /**
+     * The CloudWatch log group.
+     */
+    readonly logGroup: ILogGroup;
+}
+/**
+ * Filtering criteria that determine which queries are logged.
+ */
+export interface LoggingFilter {
+    /**
+     * Integer.
+     *
+     * Minimum 0
+     */
+    readonly qspThreshold: number;
+}
+/**
+ * The logging destination in an Amazon Managed Service for Prometheus workspace.
+ */
+export interface LoggingDestination {
+    /**
+     * Configuration details for logging to CloudWatch Logs.
+     */
+    readonly cloudWatchLogs: CloudWatchLogDestination;
+    /**
+     * Filtering criteria that determine which queries are logged.
+     */
+    readonly filters: LoggingFilter;
+}
+/**
+ * The query logging configuration in an Amazon Managed Service for Prometheus workspace.
+ */
+export interface QueryLoggingConfiguration {
+    /**
+     * Defines a destination and its associated filtering criteria for query logging.
+     *
+     * Minimum 1 and maximum 1 item in array.
+     */
+    readonly destinations: LoggingDestination[];
+}
+/**
+ *  This structure contains the limits that apply to time series that match one label set.
+ */
+export interface LimitsPerLabelSetEntry {
+    /**
+     * The maximum number of active series that can be ingested that match this label set.
+     * Setting this to 0 causes no label set limit to be enforced, but it does cause Amazon Managed
+     * Service for Prometheus to vend label set metrics to CloudWatch Logs.
+     *
+     * Minimum 0
+     */
+    readonly maxSeries?: number;
+}
+/**
+ * A label is a name:value pair used to add context to ingested metrics. This structure defines the
+ * name and value for one label that is used in a label set. You can set ingestion limits on time
+ * series that match defined label sets, to help prevent a workspace from being overwhelmed with
+ * unexpected spikes in time series ingestion.
+ */
+export interface Label {
+    /**
+     * The name for this label.
+     *
+     * Pattern: ^[a-zA-Z_][a-zA-Z0-9_]*$
+     *
+     * At least one character.
+     */
+    readonly name: string;
+    /**
+     * The value for this label.
+     *
+     * At least one character.
+     */
+    readonly value: string;
+}
+/**
+ * This defines a label set for the workspace, and defines the ingestion limit for active time
+ * series that match that label set. Each label name in a label set must be unique.
+ */
+export interface LimitsPerLabelSet {
+    /**
+     * This defines one label set that will have an enforced ingestion limit. You can set ingestion
+     * limits on time series that match defined label sets, to help prevent a workspace from being
+     * overwhelmed with unexpected spikes in time series ingestion.
+     *
+     * Label values accept all UTF-8 characters with one exception. If the label name is metric
+     * name label __name__, then the metric part of the name must conform to the following pattern:
+     * [a-zA-Z_:][a-zA-Z0-9_:]*
+     *
+     * Minimum 0
+     */
+    readonly labelSet: Label[];
+    /**
+     * This structure contains the information about the limits that apply to time series that
+     * match this label set.
+     */
+    readonly limits: LimitsPerLabelSetEntry;
+}
+/**
+ * Use this structure to define label sets and the ingestion limits for time series that match
+ * label sets, and to specify the retention period of the workspace.
+ */
+export interface WorkspaceConfiguration {
+    /**
+     * This is an array of structures, where each structure defines a label set for the workspace,
+     * and defines the ingestion limit for active time series for each of those label sets. Each
+     * label name in a label set must be unique.
+     *
+     * Minimum 0
+     */
+    readonly limitsPerLabelSets?: LimitsPerLabelSet[];
+    /**
+     * Specifies how many days that metrics will be retained in the workspace.
+     *
+     * Minimum 1
+     */
+    readonly retentionPeriodInDays?: number;
+}
+export interface IWorkspace extends IResource {
+    /**
+     * The alert manager definition, a YAML configuration for the alert manager in your Amazon
+     * Managed Service for Prometheus workspace.
+     */
+    readonly alertManagerDefinition?: string;
+    /**
+     * The alias that is assigned to this workspace to help identify it. It does not need to be
+     * unique.
+     */
+    readonly alias?: string;
+    /**
+     * The customer managed AWS KMS key to use for encrypting data within your workspace.
+     */
+    readonly kmsKey?: IKey;
+    /**
+     * Contains information about the current rules and alerting logging configuration for the
+     * workspace.
+     *
+     * Note: These logging configurations are only for rules and alerting logs.
+     */
+    readonly loggingConfiguration?: LoggingConfiguration;
+    /**
+     * The definition of logging configuration in an Amazon Managed Service for Prometheus workspace.
+     */
+    readonly queryLoggingConfiguration?: QueryLoggingConfiguration;
+    /**
+     * Use this structure to define label sets and the ingestion limits for time series that match
+     * label sets, and to specify the retention period of the workspace.
+     */
+    readonly workspaceConfiguration?: WorkspaceConfiguration;
+    /**
+     * The unique ID for the workspace.
+     * @attribute
+     */
+    readonly workspaceId: string;
+    /**
+     * The ARN of the workspace.
+     * @attribute
+     */
+    readonly workspaceArn: string;
+}
+export declare abstract class WorkspaceBase extends Resource implements IWorkspace {
+    /**
+     * The alert manager definition, a YAML configuration for the alert manager in your Amazon
+     * Managed Service for Prometheus workspace.
+     */
+    abstract readonly alertManagerDefinition?: string;
+    /**
+     * The alias that is assigned to this workspace to help identify it. It does not need to be
+     * unique.
+     */
+    abstract readonly alias?: string;
+    /**
+     * The customer managed AWS KMS key to use for encrypting data within your workspace.
+     */
+    abstract readonly kmsKey?: IKey;
+    /**
+     * Contains information about the current rules and alerting logging configuration for the
+     * workspace.
+     *
+     * Note: These logging configurations are only for rules and alerting logs.
+     */
+    abstract readonly loggingConfiguration?: LoggingConfiguration;
+    /**
+     * The definition of logging configuration in an Amazon Managed Service for Prometheus workspace.
+     */
+    abstract readonly queryLoggingConfiguration?: QueryLoggingConfiguration;
+    /**
+     * Use this structure to define label sets and the ingestion limits for time series that match
+     * label sets, and to specify the retention period of the workspace.
+     */
+    abstract readonly workspaceConfiguration?: WorkspaceConfiguration;
+    /**
+     * The unique ID for the workspace.
+     */
+    abstract readonly workspaceId: string;
+    /**
+     * The ARN of the workspace.
+     */
+    abstract readonly workspaceArn: string;
+    protected getWorkspaceId(workspaceArn: string): string;
+}

package/lib/workspace-base.js

@@ -0,0 +1,15 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceBase = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+class WorkspaceBase extends aws_cdk_lib_1.Resource {
+    getWorkspaceId(workspaceArn) {
+        return workspaceArn.substring(workspaceArn.lastIndexOf('/') + 1);
+    }
+}
+exports.WorkspaceBase = WorkspaceBase;
+_a = JSII_RTTI_SYMBOL_1;
+WorkspaceBase[_a] = { fqn: "@robhan-cdk-lib/aws_aps.WorkspaceBase", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspace-base.js","sourceRoot":"","sources":["../src/workspace-base.ts"],"names":[],"mappings":";;;;;AAAA,6CAAkD;AAoMlD,MAAsB,aAAc,SAAQ,sBAAQ;IA+CxC,cAAc,CAAC,YAAoB;QAC3C,OAAO,YAAY,CAAC,SAAS,CAAC,YAAY,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IACnE,CAAC;;AAjDH,sCAkDC","sourcesContent":["import { IResource, Resource } from 'aws-cdk-lib';\nimport { IKey } from 'aws-cdk-lib/aws-kms';\nimport { ILogGroup } from 'aws-cdk-lib/aws-logs';\n\n/**\n * Contains information about the rules and alerting logging configuration for the workspace.\n */\nexport interface LoggingConfiguration {\n  /**\n   * The CloudWatch log group to which the vended log data will be published.\n   */\n  readonly logGroup?: ILogGroup;\n}\n\n/**\n * Configuration details for logging to CloudWatch Logs.\n */\nexport interface CloudWatchLogDestination {\n  /**\n   * The CloudWatch log group.\n   */\n  readonly logGroup: ILogGroup;\n}\n\n/**\n * Filtering criteria that determine which queries are logged.\n */\nexport interface LoggingFilter {\n  /**\n   * Integer.\n   *\n   * Minimum 0\n   */\n  readonly qspThreshold: number;\n}\n\n/**\n * The logging destination in an Amazon Managed Service for Prometheus workspace.\n */\nexport interface LoggingDestination {\n  /**\n   * Configuration details for logging to CloudWatch Logs.\n   */\n  readonly cloudWatchLogs: CloudWatchLogDestination;\n  /**\n   * Filtering criteria that determine which queries are logged.\n   */\n  readonly filters: LoggingFilter;\n}\n\n/**\n * The query logging configuration in an Amazon Managed Service for Prometheus workspace.\n */\nexport interface QueryLoggingConfiguration {\n  /**\n   * Defines a destination and its associated filtering criteria for query logging.\n   *\n   * Minimum 1 and maximum 1 item in array.\n   */\n  readonly destinations: LoggingDestination[];\n}\n\n/**\n *  This structure contains the limits that apply to time series that match one label set.\n */\nexport interface LimitsPerLabelSetEntry {\n  /**\n   * The maximum number of active series that can be ingested that match this label set.\n   * Setting this to 0 causes no label set limit to be enforced, but it does cause Amazon Managed\n   * Service for Prometheus to vend label set metrics to CloudWatch Logs.\n   *\n   * Minimum 0\n   */\n  readonly maxSeries?: number;\n}\n\n/**\n * A label is a name:value pair used to add context to ingested metrics. This structure defines the\n * name and value for one label that is used in a label set. You can set ingestion limits on time\n * series that match defined label sets, to help prevent a workspace from being overwhelmed with\n * unexpected spikes in time series ingestion.\n */\nexport interface Label {\n  /**\n   * The name for this label.\n   *\n   * Pattern: ^[a-zA-Z_][a-zA-Z0-9_]*$\n   *\n   * At least one character.\n   */\n  readonly name: string;\n  /**\n   * The value for this label.\n   *\n   * At least one character.\n   */\n  readonly value: string;\n}\n\n/**\n * This defines a label set for the workspace, and defines the ingestion limit for active time\n * series that match that label set. Each label name in a label set must be unique.\n */\nexport interface LimitsPerLabelSet {\n  /**\n   * This defines one label set that will have an enforced ingestion limit. You can set ingestion\n   * limits on time series that match defined label sets, to help prevent a workspace from being\n   * overwhelmed with unexpected spikes in time series ingestion.\n   *\n   * Label values accept all UTF-8 characters with one exception. If the label name is metric\n   * name label __name__, then the metric part of the name must conform to the following pattern:\n   * [a-zA-Z_:][a-zA-Z0-9_:]*\n   *\n   * Minimum 0\n   */\n  readonly labelSet: Label[];\n\n  /**\n   * This structure contains the information about the limits that apply to time series that\n   * match this label set.\n   */\n  readonly limits: LimitsPerLabelSetEntry;\n}\n\n/**\n * Use this structure to define label sets and the ingestion limits for time series that match\n * label sets, and to specify the retention period of the workspace.\n */\nexport interface WorkspaceConfiguration {\n  /**\n   * This is an array of structures, where each structure defines a label set for the workspace,\n   * and defines the ingestion limit for active time series for each of those label sets. Each\n   * label name in a label set must be unique.\n   *\n   * Minimum 0\n   */\n  readonly limitsPerLabelSets?: LimitsPerLabelSet[];\n\n  /**\n   * Specifies how many days that metrics will be retained in the workspace.\n   *\n   * Minimum 1\n   */\n  readonly retentionPeriodInDays?: number;\n}\n\nexport interface IWorkspace extends IResource {\n  /**\n   * The alert manager definition, a YAML configuration for the alert manager in your Amazon\n   * Managed Service for Prometheus workspace.\n   */\n  readonly alertManagerDefinition?: string;\n\n  /**\n   * The alias that is assigned to this workspace to help identify it. It does not need to be\n   * unique.\n   */\n  readonly alias?: string;\n\n  /**\n   * The customer managed AWS KMS key to use for encrypting data within your workspace.\n   */\n  readonly kmsKey?: IKey;\n\n  /**\n   * Contains information about the current rules and alerting logging configuration for the\n   * workspace.\n   *\n   * Note: These logging configurations are only for rules and alerting logs.\n   */\n  readonly loggingConfiguration?: LoggingConfiguration;\n\n  /**\n   * The definition of logging configuration in an Amazon Managed Service for Prometheus workspace.\n   */\n  readonly queryLoggingConfiguration?: QueryLoggingConfiguration;\n\n  /**\n   * Use this structure to define label sets and the ingestion limits for time series that match\n   * label sets, and to specify the retention period of the workspace.\n   */\n  readonly workspaceConfiguration?: WorkspaceConfiguration;\n\n  /**\n   * The unique ID for the workspace.\n   * @attribute\n   */\n  readonly workspaceId: string;\n\n  /**\n   * The ARN of the workspace.\n   * @attribute\n   */\n  readonly workspaceArn: string;\n}\n\nexport abstract class WorkspaceBase extends Resource implements IWorkspace {\n  /**\n   * The alert manager definition, a YAML configuration for the alert manager in your Amazon\n   * Managed Service for Prometheus workspace.\n   */\n  public abstract readonly alertManagerDefinition?: string;\n\n  /**\n   * The alias that is assigned to this workspace to help identify it. It does not need to be\n   * unique.\n   */\n  public abstract readonly alias?: string;\n\n  /**\n   * The customer managed AWS KMS key to use for encrypting data within your workspace.\n   */\n  public abstract readonly kmsKey?: IKey;\n\n  /**\n   * Contains information about the current rules and alerting logging configuration for the\n   * workspace.\n   *\n   * Note: These logging configurations are only for rules and alerting logs.\n   */\n  public abstract readonly loggingConfiguration?: LoggingConfiguration;\n\n  /**\n   * The definition of logging configuration in an Amazon Managed Service for Prometheus workspace.\n   */\n  public abstract readonly queryLoggingConfiguration?: QueryLoggingConfiguration;\n\n  /**\n   * Use this structure to define label sets and the ingestion limits for time series that match\n   * label sets, and to specify the retention period of the workspace.\n   */\n  public abstract readonly workspaceConfiguration?: WorkspaceConfiguration;\n\n  /**\n   * The unique ID for the workspace.\n   */\n  public abstract readonly workspaceId: string;\n\n  /**\n   * The ARN of the workspace.\n   */\n  public abstract readonly workspaceArn: string;\n\n  protected getWorkspaceId(workspaceArn: string) {\n    return workspaceArn.substring(workspaceArn.lastIndexOf('/') + 1);\n  }\n}"]}