@rio-cloud/cdk-v2-constructs 9.0.0-alpha.8 → 9.0.0-alpha.9

package/lib/fargate/trace-sampling.d.ts

@@ -0,0 +1,87 @@
+import type * as constructs from 'constructs';
+/**
+ * The trace sampling strategy used by the Fargate Datadog integration.
+ */
+export declare enum TraceSamplingMode {
+    /**
+     * Use RIO's per-Agent head-sampling target of 5 traces/sec and an additional
+     * error-sampling budget of 10 local error trace chunks/sec.
+     * Target-per-second sampling is a practical default for both low- and
+     * high-traffic services.
+     */
+    DEFAULT = 0,
+    /** Do not set sampling environment variables; retain Datadog's defaults. */
+    DATADOG_DEFAULT = 1,
+    /** Set a fixed sampling rule on the application tracer. */
+    FIXED_RATE = 2,
+    /** Set a per-Agent target number of traces per second. */
+    TARGET_PER_SECOND = 3
+}
+/**
+ * Use RIO's default Datadog Agent sampling targets.
+ *
+ * This is also the default when `traceSampling` is omitted.
+ */
+export interface RioDefaultTraceSamplingOptions {
+    /**
+     * The sampling strategy. May be omitted to use the default.
+     *
+     * @defaultValue - `TraceSamplingMode.DEFAULT`
+     */
+    readonly mode?: TraceSamplingMode.DEFAULT;
+}
+/** Do not set sampling environment variables; retain Datadog's defaults. */
+export interface DatadogDefaultTraceSamplingOptions {
+    /** The sampling strategy. */
+    readonly mode: TraceSamplingMode.DATADOG_DEFAULT;
+}
+/** Configure a fixed application-tracer sampling rate. */
+export interface FixedRateTraceSamplingOptions {
+    /** The sampling strategy. */
+    readonly mode: TraceSamplingMode.FIXED_RATE;
+    /**
+     * The global tracer sampling-rule rate, from 0.0 to 1.0 inclusive.
+     * Datadog tracers additionally apply their built-in 100-traces-per-second
+     * rate limit when sampling rules are configured. This construct does not
+     * expose or override that per-instance safeguard.
+     */
+    readonly fixedRate: number;
+}
+/** Configure Datadog Agent target sampling. */
+export interface TargetPerSecondTraceSamplingOptions {
+    /** The sampling strategy. */
+    readonly mode: TraceSamplingMode.TARGET_PER_SECOND;
+    /**
+     * The average head-sampling target in traces per second for each Agent
+     * sidecar (and therefore each Fargate service instance). Traffic spikes
+     * can exceed this target; it is not a hard cap on total ingestion.
+     */
+    readonly targetTracesPerSecond: number;
+    /**
+     * The budget for additional local error trace chunks per second missed by
+     * head sampling, for each Agent sidecar (and therefore each Fargate service
+     * instance). This does not cap error traces already kept by head sampling.
+     */
+    readonly errorTracesPerSecond?: number;
+}
+/**
+ * Options for configuring Datadog APM trace sampling.
+ *
+ * This discriminated union makes mode-specific settings invalid in TypeScript
+ * before synthesis. Numeric ranges are checked during synthesis.
+ */
+export type TraceSamplingOptions = RioDefaultTraceSamplingOptions | DatadogDefaultTraceSamplingOptions | FixedRateTraceSamplingOptions | TargetPerSecondTraceSamplingOptions;
+export declare class TraceSamplingValidator implements constructs.IValidation {
+    private readonly traceSampling?;
+    constructor(traceSampling?: TraceSamplingOptions | undefined);
+    validate(): string[];
+}
+export declare function addTraceSamplingEnvironmentWarning(scope: constructs.Construct, environment: {
+    [key: string]: string;
+} | undefined): void;
+export declare function getApplicationTraceSamplingEnvironment(traceSampling?: TraceSamplingOptions): {
+    [key: string]: string;
+};
+export declare function getAgentTraceSamplingEnvironment(traceSampling?: TraceSamplingOptions): {
+    [key: string]: string;
+};

package/lib/fargate/trace-sampling.js

@@ -0,0 +1,123 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceSamplingValidator = exports.TraceSamplingMode = void 0;
+exports.addTraceSamplingEnvironmentWarning = addTraceSamplingEnvironmentWarning;
+exports.getApplicationTraceSamplingEnvironment = getApplicationTraceSamplingEnvironment;
+exports.getAgentTraceSamplingEnvironment = getAgentTraceSamplingEnvironment;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk = require("aws-cdk-lib");
+/**
+ * The trace sampling strategy used by the Fargate Datadog integration.
+ */
+var TraceSamplingMode;
+(function (TraceSamplingMode) {
+    /**
+     * Use RIO's per-Agent head-sampling target of 5 traces/sec and an additional
+     * error-sampling budget of 10 local error trace chunks/sec.
+     * Target-per-second sampling is a practical default for both low- and
+     * high-traffic services.
+     */
+    TraceSamplingMode[TraceSamplingMode["DEFAULT"] = 0] = "DEFAULT";
+    /** Do not set sampling environment variables; retain Datadog's defaults. */
+    TraceSamplingMode[TraceSamplingMode["DATADOG_DEFAULT"] = 1] = "DATADOG_DEFAULT";
+    /** Set a fixed sampling rule on the application tracer. */
+    TraceSamplingMode[TraceSamplingMode["FIXED_RATE"] = 2] = "FIXED_RATE";
+    /** Set a per-Agent target number of traces per second. */
+    TraceSamplingMode[TraceSamplingMode["TARGET_PER_SECOND"] = 3] = "TARGET_PER_SECOND";
+})(TraceSamplingMode || (exports.TraceSamplingMode = TraceSamplingMode = {}));
+class TraceSamplingValidator {
+    constructor(traceSampling) {
+        this.traceSampling = traceSampling;
+    }
+    validate() {
+        const options = this.traceSampling;
+        if (!options) {
+            return [];
+        }
+        // Keep validating the runtime shape: JavaScript consumers and TypeScript
+        // callers using a cast can bypass the discriminated union.
+        const values = options;
+        const mode = values.mode ?? TraceSamplingMode.DEFAULT;
+        const hasFixedRate = values.fixedRate !== undefined;
+        const hasTargetTps = values.targetTracesPerSecond !== undefined;
+        const hasErrorTps = values.errorTracesPerSecond !== undefined;
+        const errors = [];
+        const isNonNegativeInteger = (value) => value !== undefined && Number.isInteger(value) && value >= 0;
+        if (mode === TraceSamplingMode.DEFAULT || mode === TraceSamplingMode.DATADOG_DEFAULT) {
+            if (hasFixedRate || hasTargetTps || hasErrorTps) {
+                errors.push(`${TraceSamplingMode[mode]} does not accept fixedRate, targetTracesPerSecond, or errorTracesPerSecond.`);
+            }
+        }
+        else if (mode === TraceSamplingMode.FIXED_RATE) {
+            const fixedRate = values.fixedRate;
+            if (!hasFixedRate ||
+                fixedRate === undefined ||
+                !Number.isFinite(fixedRate) ||
+                fixedRate < 0.0 ||
+                fixedRate > 1.0) {
+                errors.push('FIXED_RATE requires fixedRate to be a number between 0 and 1 inclusive.');
+            }
+            if (hasTargetTps) {
+                errors.push('FIXED_RATE does not accept targetTracesPerSecond.');
+            }
+            if (hasErrorTps) {
+                errors.push('FIXED_RATE does not accept errorTracesPerSecond.');
+            }
+        }
+        else if (mode === TraceSamplingMode.TARGET_PER_SECOND) {
+            if (!isNonNegativeInteger(values.targetTracesPerSecond)) {
+                errors.push('TARGET_PER_SECOND requires targetTracesPerSecond to be a non-negative integer.');
+            }
+            if (hasFixedRate) {
+                errors.push('TARGET_PER_SECOND does not accept fixedRate.');
+            }
+            if (hasErrorTps && !isNonNegativeInteger(values.errorTracesPerSecond)) {
+                errors.push('TARGET_PER_SECOND errorTracesPerSecond must be a non-negative integer.');
+            }
+        }
+        else {
+            errors.push('traceSampling.mode must be a TraceSamplingMode value.');
+        }
+        return errors;
+    }
+}
+exports.TraceSamplingValidator = TraceSamplingValidator;
+_a = JSII_RTTI_SYMBOL_1;
+TraceSamplingValidator[_a] = { fqn: "@rio-cloud-internal/cdk-v2-constructs.TraceSamplingValidator", version: "0.0.0" };
+function addTraceSamplingEnvironmentWarning(scope, environment) {
+    const samplingKeys = ['DD_TRACE_SAMPLING_RULES', 'DD_TRACE_SAMPLE_RATE', 'DD_APM_TARGET_TPS', 'DD_APM_ERROR_TPS'];
+    const configuredKeys = samplingKeys.filter(key => environment && key in environment);
+    if (configuredKeys.length > 0) {
+        cdk.Validations.of(scope).addWarning('@rio-cloud/cdk-v2-constructs:directTraceSamplingEnvironment', [
+            `Direct trace-sampling environment variable(s) detected: ${configuredKeys.join(', ')}.`,
+            'Recommended action: remove these variables to use the DEFAULT sampling policy.',
+            'To select a different policy, configure datadogOptions.traceSampling explicitly.',
+            'Direct sampling environment variables remain supported only for backwards compatibility. Users who choose them are responsible for their compatibility and maintenance.',
+        ].join('\n'));
+    }
+}
+function getApplicationTraceSamplingEnvironment(traceSampling) {
+    if (traceSampling?.mode === TraceSamplingMode.FIXED_RATE) {
+        const rules = [{ sample_rate: traceSampling.fixedRate }];
+        return { DD_TRACE_SAMPLING_RULES: JSON.stringify(rules) };
+    }
+    return {};
+}
+function getAgentTraceSamplingEnvironment(traceSampling) {
+    if (traceSampling?.mode === undefined || traceSampling.mode === TraceSamplingMode.DEFAULT) {
+        return { DD_APM_TARGET_TPS: '5', DD_APM_ERROR_TPS: '10' };
+    }
+    if (traceSampling?.mode === TraceSamplingMode.TARGET_PER_SECOND) {
+        const environment = {};
+        if (traceSampling.targetTracesPerSecond !== undefined) {
+            environment.DD_APM_TARGET_TPS = String(traceSampling.targetTracesPerSecond);
+        }
+        if (traceSampling.errorTracesPerSecond !== undefined) {
+            environment.DD_APM_ERROR_TPS = String(traceSampling.errorTracesPerSecond);
+        }
+        return environment;
+    }
+    return {};
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trace-sampling.js","sourceRoot":"","sources":["../../src/fargate/trace-sampling.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport type * as constructs from 'constructs';\n\n/**\n * The trace sampling strategy used by the Fargate Datadog integration.\n */\nexport enum TraceSamplingMode {\n  /**\n   * Use RIO's per-Agent head-sampling target of 5 traces/sec and an additional\n   * error-sampling budget of 10 local error trace chunks/sec.\n   * Target-per-second sampling is a practical default for both low- and\n   * high-traffic services.\n   */\n  DEFAULT,\n\n  /** Do not set sampling environment variables; retain Datadog's defaults. */\n  DATADOG_DEFAULT,\n\n  /** Set a fixed sampling rule on the application tracer. */\n  FIXED_RATE,\n\n  /** Set a per-Agent target number of traces per second. */\n  TARGET_PER_SECOND,\n}\n\n/**\n * Use RIO's default Datadog Agent sampling targets.\n *\n * This is also the default when `traceSampling` is omitted.\n */\nexport interface RioDefaultTraceSamplingOptions {\n  /**\n   * The sampling strategy. May be omitted to use the default.\n   *\n   * @defaultValue - `TraceSamplingMode.DEFAULT`\n   */\n  readonly mode?: TraceSamplingMode.DEFAULT;\n}\n\n/** Do not set sampling environment variables; retain Datadog's defaults. */\nexport interface DatadogDefaultTraceSamplingOptions {\n  /** The sampling strategy. */\n  readonly mode: TraceSamplingMode.DATADOG_DEFAULT;\n}\n\n/** Configure a fixed application-tracer sampling rate. */\nexport interface FixedRateTraceSamplingOptions {\n  /** The sampling strategy. */\n  readonly mode: TraceSamplingMode.FIXED_RATE;\n\n  /**\n   * The global tracer sampling-rule rate, from 0.0 to 1.0 inclusive.\n   * Datadog tracers additionally apply their built-in 100-traces-per-second\n   * rate limit when sampling rules are configured. This construct does not\n   * expose or override that per-instance safeguard.\n   */\n  readonly fixedRate: number;\n}\n\n/** Configure Datadog Agent target sampling. */\nexport interface TargetPerSecondTraceSamplingOptions {\n  /** The sampling strategy. */\n  readonly mode: TraceSamplingMode.TARGET_PER_SECOND;\n\n  /**\n   * The average head-sampling target in traces per second for each Agent\n   * sidecar (and therefore each Fargate service instance). Traffic spikes\n   * can exceed this target; it is not a hard cap on total ingestion.\n   */\n  readonly targetTracesPerSecond: number;\n\n  /**\n   * The budget for additional local error trace chunks per second missed by\n   * head sampling, for each Agent sidecar (and therefore each Fargate service\n   * instance). This does not cap error traces already kept by head sampling.\n   */\n  readonly errorTracesPerSecond?: number;\n}\n\n/**\n * Options for configuring Datadog APM trace sampling.\n *\n * This discriminated union makes mode-specific settings invalid in TypeScript\n * before synthesis. Numeric ranges are checked during synthesis.\n */\nexport type TraceSamplingOptions =\n  | RioDefaultTraceSamplingOptions\n  | DatadogDefaultTraceSamplingOptions\n  | FixedRateTraceSamplingOptions\n  | TargetPerSecondTraceSamplingOptions;\n\n/** The untrusted runtime shape used by synthesis-time validation. */\ntype TraceSamplingValues = {\n  readonly mode?: TraceSamplingMode;\n  readonly fixedRate?: number;\n  readonly targetTracesPerSecond?: number;\n  readonly errorTracesPerSecond?: number;\n};\n\nexport class TraceSamplingValidator implements constructs.IValidation {\n  constructor(private readonly traceSampling?: TraceSamplingOptions) {}\n\n  validate(): string[] {\n    const options = this.traceSampling;\n    if (!options) {\n      return [];\n    }\n\n    // Keep validating the runtime shape: JavaScript consumers and TypeScript\n    // callers using a cast can bypass the discriminated union.\n    const values = options as TraceSamplingValues;\n    const mode = values.mode ?? TraceSamplingMode.DEFAULT;\n    const hasFixedRate = values.fixedRate !== undefined;\n    const hasTargetTps = values.targetTracesPerSecond !== undefined;\n    const hasErrorTps = values.errorTracesPerSecond !== undefined;\n    const errors: string[] = [];\n    const isNonNegativeInteger = (value: number | undefined) =>\n      value !== undefined && Number.isInteger(value) && value >= 0;\n\n    if (mode === TraceSamplingMode.DEFAULT || mode === TraceSamplingMode.DATADOG_DEFAULT) {\n      if (hasFixedRate || hasTargetTps || hasErrorTps) {\n        errors.push(\n          `${TraceSamplingMode[mode]} does not accept fixedRate, targetTracesPerSecond, or errorTracesPerSecond.`\n        );\n      }\n    } else if (mode === TraceSamplingMode.FIXED_RATE) {\n      const fixedRate = values.fixedRate;\n      if (\n        !hasFixedRate ||\n        fixedRate === undefined ||\n        !Number.isFinite(fixedRate) ||\n        fixedRate < 0.0 ||\n        fixedRate > 1.0\n      ) {\n        errors.push('FIXED_RATE requires fixedRate to be a number between 0 and 1 inclusive.');\n      }\n      if (hasTargetTps) {\n        errors.push('FIXED_RATE does not accept targetTracesPerSecond.');\n      }\n      if (hasErrorTps) {\n        errors.push('FIXED_RATE does not accept errorTracesPerSecond.');\n      }\n    } else if (mode === TraceSamplingMode.TARGET_PER_SECOND) {\n      if (!isNonNegativeInteger(values.targetTracesPerSecond)) {\n        errors.push('TARGET_PER_SECOND requires targetTracesPerSecond to be a non-negative integer.');\n      }\n      if (hasFixedRate) {\n        errors.push('TARGET_PER_SECOND does not accept fixedRate.');\n      }\n      if (hasErrorTps && !isNonNegativeInteger(values.errorTracesPerSecond)) {\n        errors.push('TARGET_PER_SECOND errorTracesPerSecond must be a non-negative integer.');\n      }\n    } else {\n      errors.push('traceSampling.mode must be a TraceSamplingMode value.');\n    }\n\n    return errors;\n  }\n}\n\nexport function addTraceSamplingEnvironmentWarning(\n  scope: constructs.Construct,\n  environment: { [key: string]: string } | undefined\n): void {\n  const samplingKeys = ['DD_TRACE_SAMPLING_RULES', 'DD_TRACE_SAMPLE_RATE', 'DD_APM_TARGET_TPS', 'DD_APM_ERROR_TPS'];\n  const configuredKeys = samplingKeys.filter(key => environment && key in environment);\n  if (configuredKeys.length > 0) {\n    cdk.Validations.of(scope).addWarning(\n      '@rio-cloud/cdk-v2-constructs:directTraceSamplingEnvironment',\n      [\n        `Direct trace-sampling environment variable(s) detected: ${configuredKeys.join(', ')}.`,\n        'Recommended action: remove these variables to use the DEFAULT sampling policy.',\n        'To select a different policy, configure datadogOptions.traceSampling explicitly.',\n        'Direct sampling environment variables remain supported only for backwards compatibility. Users who choose them are responsible for their compatibility and maintenance.',\n      ].join('\\n')\n    );\n  }\n}\n\nexport function getApplicationTraceSamplingEnvironment(traceSampling?: TraceSamplingOptions): {\n  [key: string]: string;\n} {\n  if (traceSampling?.mode === TraceSamplingMode.FIXED_RATE) {\n    const rules = [{ sample_rate: traceSampling.fixedRate }];\n    return { DD_TRACE_SAMPLING_RULES: JSON.stringify(rules) };\n  }\n  return {};\n}\n\nexport function getAgentTraceSamplingEnvironment(traceSampling?: TraceSamplingOptions): { [key: string]: string } {\n  if (traceSampling?.mode === undefined || traceSampling.mode === TraceSamplingMode.DEFAULT) {\n    return { DD_APM_TARGET_TPS: '5', DD_APM_ERROR_TPS: '10' };\n  }\n  if (traceSampling?.mode === TraceSamplingMode.TARGET_PER_SECOND) {\n    const environment: { [key: string]: string } = {};\n    if (traceSampling.targetTracesPerSecond !== undefined) {\n      environment.DD_APM_TARGET_TPS = String(traceSampling.targetTracesPerSecond);\n    }\n    if (traceSampling.errorTracesPerSecond !== undefined) {\n      environment.DD_APM_ERROR_TPS = String(traceSampling.errorTracesPerSecond);\n    }\n    return environment;\n  }\n  return {};\n}\n"]}

package/package.json

@@ -15,7 +15,7 @@
   ],
   "main": "lib/index.js",
   "license": "Apache-2.0",
-  "version": "9.0.0-alpha.8",
+  "version": "9.0.0-alpha.9",
   "types": "lib/index.d.ts",
   "stability": "stable",
   "exports": {

package/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "9.0.0-alpha.8"
+  "version": "9.0.0-alpha.9"
 }