@aws-cdk/aws-glue-alpha 2.268.0-alpha.0 → 2.270.0-alpha.0

package/lib/jobs/job.js

@@ -51,7 +51,22 @@ const secret_detection_1 = require("../private/secret-detection");
  * event-driven flow using the job.
  */
 class JobBase extends cdk.Resource {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-glue-alpha.JobBase", version: "2.268.0-alpha.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-glue-alpha.JobBase", version: "2.270.0-alpha.0" };
+    /**
+     * A reference to this Job resource, for use with the generated L1 ref interface.
+     */
+    get jobRef() {
+        try {
+            jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.JobBase#jobRef", "");
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, jsiiDeprecationWarnings.getPropertyDescriptor(this, "jobRef").get);
+            }
+            throw error;
+        }
+        return { jobName: this.jobName };
+    }
     /**
      * Create a CloudWatch Event Rule for this Glue Job when it's in a given state
      *
@@ -64,6 +79,15 @@ class JobBase extends cdk.Resource {
      * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types
      */
     onEvent(id, options = {}) {
+        try {
+            jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.JobBase#onEvent", "");
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.onEvent);
+            }
+            throw error;
+        }
         const rule = new events.Rule(this, id, options);
         rule.addTarget(options.target);
         rule.addEventPattern({
@@ -84,6 +108,7 @@ class JobBase extends cdk.Resource {
      */
     onStateChange(id, jobState, options = {}) {
         try {
+            jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.JobBase#onStateChange", "");
             jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_JobState(jobState);
         }
         catch (error) {
@@ -110,6 +135,15 @@ class JobBase extends cdk.Resource {
      * @param options optional event options. default is {}.
      */
     onSuccess(id, options = {}) {
+        try {
+            jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.JobBase#onSuccess", "");
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.onSuccess);
+            }
+            throw error;
+        }
         return this.onStateChange(id, constants_1.JobState.SUCCEEDED, options);
     }
     /**
@@ -119,6 +153,15 @@ class JobBase extends cdk.Resource {
      * @param options optional event options. default is {}.
      */
     onFailure(id, options = {}) {
+        try {
+            jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.JobBase#onFailure", "");
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.onFailure);
+            }
+            throw error;
+        }
         return this.onStateChange(id, constants_1.JobState.FAILED, options);
     }
     /**
@@ -128,6 +171,15 @@ class JobBase extends cdk.Resource {
      * @param options optional event options. default is {}.
      */
     onTimeout(id, options = {}) {
+        try {
+            jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.JobBase#onTimeout", "");
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.onTimeout);
+            }
+            throw error;
+        }
         return this.onStateChange(id, constants_1.JobState.TIMEOUT, options);
     }
     /**
@@ -141,6 +193,7 @@ class JobBase extends cdk.Resource {
      */
     metric(metricName, type, props) {
         try {
+            jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.JobBase#metric", "");
             jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_MetricType(type);
         }
         catch (error) {
@@ -166,6 +219,15 @@ class JobBase extends cdk.Resource {
      * This metric is based on the Rule returned by no-args onSuccess() call.
      */
     metricSuccess(props) {
+        try {
+            jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.JobBase#metricSuccess", "");
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.metricSuccess);
+            }
+            throw error;
+        }
         return metricRule(this.metricJobStateRule('SuccessMetricRule', constants_1.JobState.SUCCEEDED), props);
     }
     /**
@@ -174,6 +236,15 @@ class JobBase extends cdk.Resource {
      * This metric is based on the Rule returned by no-args onFailure() call.
      */
     metricFailure(props) {
+        try {
+            jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.JobBase#metricFailure", "");
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.metricFailure);
+            }
+            throw error;
+        }
         return metricRule(this.metricJobStateRule('FailureMetricRule', constants_1.JobState.FAILED), props);
     }
     /**
@@ -182,6 +253,15 @@ class JobBase extends cdk.Resource {
      * This metric is based on the Rule returned by no-args onTimeout() call.
      */
     metricTimeout(props) {
+        try {
+            jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.JobBase#metricTimeout", "");
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.metricTimeout);
+            }
+            throw error;
+        }
         return metricRule(this.metricJobStateRule('TimeoutMetricRule', constants_1.JobState.TIMEOUT), props);
     }
     /**
@@ -197,6 +277,15 @@ class JobBase extends cdk.Resource {
      * Returns the job arn
      */
     buildJobArn(scope, jobName) {
+        try {
+            jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.JobBase#buildJobArn", "");
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.buildJobArn);
+            }
+            throw error;
+        }
         return cdk.Stack.of(scope).formatArn({
             service: 'glue',
             resource: 'job',
@@ -210,7 +299,7 @@ exports.JobBase = JobBase;
  * @resource AWS::Glue::Job
  */
 class Job extends JobBase {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-glue-alpha.Job", version: "2.268.0-alpha.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-glue-alpha.Job", version: "2.270.0-alpha.0" };
     /**
      * Identifies an existing Glue Job from a subset of attributes that can
      * be referenced from within another Stack or Construct.
@@ -221,6 +310,7 @@ class Job extends JobBase {
      */
     static fromJobAttributes(scope, id, attrs) {
         try {
+            jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.Job#fromJobAttributes", "");
             jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_JobAttributes(attrs);
         }
         catch (error) {
@@ -237,31 +327,126 @@ class Job extends JobBase {
         return new Import(scope, id);
     }
     /**
-     * Check no usage of reserved arguments.
+     * Argument keys that Glue reserves for its own use and that a caller must never set through
+     * `defaultArguments`. Unlike construct-managed arguments (which are derived from what each job
+     * class emits), these are owned by the Glue service itself and are reserved for every job type.
      *
      * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
      */
-    checkNoReservedArgs(defaultArguments) {
+    static GLUE_RESERVED_ARGUMENTS = new Set(['--debug', '--mode', '--JOB_NAME', '--endpoint']);
+    /**
+     * The construct-managed job arguments that are actually emitted for the current configuration,
+     * accumulated via {@link setManagedArgument}. Passed through to `CfnJob.defaultArguments` after
+     * being merged with the user-supplied `defaultArguments` by {@link mergeDefaultArguments}.
+     */
+    _managedArguments = {};
+    /**
+     * Every argument key this construct manages, accumulated via {@link setManagedArgument} — whether
+     * or not the current configuration emits a value for it. This is the reserved set that a
+     * user-supplied `defaultArguments` must not collide with. Registering a key even when its value
+     * is `undefined` (feature disabled or unset) is what keeps `defaultArguments` from silently
+     * re-enabling it.
+     */
+    _managedArgumentKeys = new Set();
+    /**
+     * Declare `key` as construct-managed and, when `value` is defined, emit it into the job's
+     * arguments.
+     *
+     * This is the single sink for every argument a job construct derives from its typed props (or
+     * from the job class itself). Call it once per managed key, passing `undefined` as the value when
+     * the corresponding feature is turned off or unset — the key is still reserved from
+     * `defaultArguments` either way, so a disabled feature cannot be re-enabled through the escape
+     * hatch. There is deliberately no other way for a subclass to emit a managed argument, so the
+     * reserved set can never drift from what is emitted.
+     *
+     * @param key the Glue argument key, e.g. `--enable-metrics`
+     * @param value the value to emit, or `undefined` to reserve the key without emitting it
+     */
+    setManagedArgument(key, value) {
+        try {
+            jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.Job#setManagedArgument", "");
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.setManagedArgument);
+            }
+            throw error;
+        }
+        this._managedArgumentKeys.add(key);
+        if (value !== undefined) {
+            this._managedArguments[key] = value;
+        }
+    }
+    /**
+     * Merge the customer-supplied `defaultArguments` with the arguments this construct manages.
+     *
+     * The construct owns every argument it emits — whether the value comes from a dedicated typed
+     * prop (e.g. `continuousLogging`, `enableMetrics`, `sparkUI`) or from the job class itself
+     * (e.g. `--job-language`). Those arguments, plus the arguments Glue reserves for its own use,
+     * MUST be configured through their dedicated props rather than the untyped `defaultArguments`
+     * map, so there is exactly one way to express each intent. Passing such a key through
+     * `defaultArguments` therefore throws instead of silently winning or being silently dropped.
+     *
+     * A managed key whose supplied value is identical to the construct's value is not contradictory,
+     * so it is allowed rather than rejected (auto-correcting config is preferred over errors).
+     * Glue-reserved keys are never emitted by the construct, so there is no value to reconcile and
+     * they always throw.
+     *
+     * The reserved set is `_managedArgumentKeys` — every key the construct declared through
+     * {@link setManagedArgument}, whether or not a value was emitted for it. It is deliberately NOT
+     * derived from the keys that carry a value: a typed prop that turns a feature *off* (e.g.
+     * `enableMetrics: false`) emits no value but still reserves its key, so `defaultArguments` cannot
+     * silently re-enable it.
+     *
+     * Conflict detection relies on string equality of the argument keys, which cannot see through
+     * unresolved tokens (e.g. a key produced by `CfnJson` that only resolves at deploy time). If a
+     * key is a token, the check is skipped for that key and a synthesis-time warning is emitted, so
+     * the (rare) case where a token key resolves to a managed argument at deploy time — in which the
+     * construct-managed value would silently take precedence — is surfaced rather than hidden.
+     *
+     * @param defaultArguments the caller-supplied escape-hatch arguments, if any
+     * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    mergeDefaultArguments(defaultArguments) {
+        try {
+            jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.Job#mergeDefaultArguments", "");
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.mergeDefaultArguments);
+            }
+            throw error;
+        }
         if (defaultArguments) {
-            const reservedArgs = new Set(['--debug', '--mode', '--JOB_NAME']);
-            Object.keys(defaultArguments).forEach((arg) => {
-                if (reservedArgs.has(arg)) {
-                    throw new cdk.ValidationError((0, helpers_internal_1.lit) `ReservedArgumentUsed`, `The ${arg} argument is reserved by Glue. Don't set it`, this);
-                }
-            });
+            if (Object.keys(defaultArguments).some((arg) => cdk.Token.isUnresolved(arg))) {
+                cdk.Annotations.of(this).addWarningV2('@aws-cdk/aws-glue-alpha:tokenJobArgumentKey', 'defaultArguments contains an unresolved token as an argument key, so it cannot be checked for conflicts with construct-managed arguments. If it resolves to a managed argument at deploy time, the construct-managed value will take precedence. Configure managed arguments through their dedicated props (e.g. continuousLogging, enableMetrics, enableObservabilityMetrics, sparkUI).');
+            }
+            const conflicts = Object.keys(defaultArguments).filter((arg) => Job.GLUE_RESERVED_ARGUMENTS.has(arg)
+                || (this._managedArgumentKeys.has(arg)
+                    && !(Object.hasOwn(this._managedArguments, arg) && defaultArguments[arg] === this._managedArguments[arg])));
+            if (conflicts.length > 0) {
+                throw new cdk.ValidationError((0, helpers_internal_1.lit) `ManagedJobArgument`, `the job argument(s) ${JSON.stringify(conflicts)} are managed by the construct or reserved by Glue; configure them through the corresponding props (e.g. continuousLogging, enableMetrics, enableObservabilityMetrics, sparkUI) instead of defaultArguments`, this);
+            }
         }
         (0, secret_detection_1.warnOnPlaintextSecrets)(this, defaultArguments, '@aws-cdk/aws-glue-alpha:plaintextJobArgumentSecret', 'Pass secrets to the job at runtime through AWS Secrets Manager instead of embedding them in `defaultArguments`.');
-        return defaultArguments;
+        return { ...defaultArguments, ...this._managedArguments };
     }
     /**
-     * Setup Continuous Logging Properties
-     * @param role The IAM role to use for continuous logging
+     * Register (and, when enabled, emit) the continuous-logging arguments this job manages.
+     *
+     * All five continuous-logging keys are reserved on every job type regardless of configuration:
+     * they are always registered through {@link setManagedArgument}, and carry a value only when
+     * logging is enabled. This keeps `defaultArguments` from re-enabling logging a user turned off.
+     *
+     * @param role The IAM role to grant write access to a custom log group, if one is provided
      * @param props The properties for continuous logging configuration
-     * @returns String containing the args for the continuous logging command
+     * @param securityConfiguration The security configuration attached to the job, if any
      */
-    setupContinuousLogging(role, props) {
+    setupContinuousLogging(role, props, securityConfiguration) {
         try {
+            jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.Job#setupContinuousLogging", "");
             jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_ContinuousLoggingProps(props);
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_ISecurityConfiguration(securityConfiguration);
         }
         catch (error) {
             if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
@@ -269,32 +454,28 @@ class Job extends JobBase {
             }
             throw error;
         }
-        // If the developer has explicitly disabled continuous logging return no args
-        if (props && !props.enabled) {
-            return {};
-        }
-        // Else we turn on continuous logging by default. Determine what log group to use.
-        const args = {
-            '--enable-continuous-cloudwatch-log': 'true',
-        };
-        if (props?.quiet) {
-            args['--enable-continuous-log-filter'] = 'true';
-        }
-        // If the developer provided a log group, add its name to the args and update the role.
-        if (props?.logGroup) {
-            args['--continuous-log-logGroup'] = props.logGroup.logGroupName;
-            props.logGroup.grantWrite(role);
-        }
-        if (props?.logStreamPrefix) {
-            args['--continuous-log-logStreamPrefix'] = props.logStreamPrefix;
-        }
-        if (props?.conversionPattern) {
-            args['--continuous-log-conversionPattern'] = props.conversionPattern;
+        // Continuous logging is on unless the developer has explicitly disabled it.
+        const enabled = !(props && !props.enabled);
+        // When logging is on, the logs are written to an unencrypted CloudWatch log group unless a
+        // SecurityConfiguration is attached. We cannot introspect whether the attached
+        // SecurityConfiguration actually configures cloudWatchEncryption (the ISecurityConfiguration
+        // interface only exposes the name), so we only warn when none is attached at all to avoid
+        // false positives.
+        if (enabled && !securityConfiguration) {
+            cdk.Annotations.of(this).addWarningV2('@aws-cdk/aws-glue-alpha:unencryptedContinuousLogging', 'Continuous CloudWatch logging is enabled but no SecurityConfiguration with cloudWatchEncryption is attached. Job stdout and stderr will be written to an unencrypted CloudWatch log group. See https://docs.aws.amazon.com/glue/latest/dg/encryption-security-configuration.html');
         }
-        return args;
+        // A custom log group is only wired up (and only granted write) when logging is enabled.
+        const logGroup = enabled ? props?.logGroup : undefined;
+        logGroup?.grantWrite(role);
+        this.setManagedArgument('--enable-continuous-cloudwatch-log', enabled ? 'true' : undefined);
+        this.setManagedArgument('--enable-continuous-log-filter', enabled && props?.quiet ? 'true' : undefined);
+        this.setManagedArgument('--continuous-log-logGroup', logGroup?.logGroupName);
+        this.setManagedArgument('--continuous-log-logStreamPrefix', enabled ? props?.logStreamPrefix : undefined);
+        this.setManagedArgument('--continuous-log-conversionPattern', enabled ? props?.conversionPattern : undefined);
     }
     codeS3ObjectUrl(code) {
         try {
+            jsiiDeprecationWarnings.print("@aws-cdk/aws-glue-alpha.Job#codeS3ObjectUrl", "");
             jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_Code(code);
         }
         catch (error) {
@@ -325,4 +506,4 @@ function metricRule(rule, props) {
         ...props,
     }).attachTo(rule);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"job.js","sourceRoot":"","sources":["job.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';\nimport * as events from 'aws-cdk-lib/aws-events';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport type * as logs from 'aws-cdk-lib/aws-logs';\nimport * as cdk from 'aws-cdk-lib/core';\nimport { lit } from 'aws-cdk-lib/core/lib/helpers-internal';\nimport type * as constructs from 'constructs';\nimport type { Code } from '../code';\nimport type { IConnection } from '../connection';\nimport type { MetricType, GlueVersion } from '../constants';\nimport { JobState } from '../constants';\nimport { warnOnPlaintextSecrets } from '../private/secret-detection';\nimport type { ISecurityConfiguration } from '../security-configuration';\n\n/**\n * Interface representing a new or an imported Glue Job\n */\nexport interface IJob extends cdk.IResource, iam.IGrantable {\n  /**\n   * The name of the job.\n   * @attribute\n   */\n  readonly jobName: string;\n\n  /**\n   * The ARN of the job.\n   * @attribute\n   */\n  readonly jobArn: string;\n\n  /**\n   * Defines a CloudWatch event rule triggered when something happens with this job.\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types\n   */\n  onEvent(id: string, options?: events.OnEventOptions): events.Rule;\n\n  /**\n   * Defines a CloudWatch event rule triggered when this job moves to the SUCCEEDED state.\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types\n   */\n  onSuccess(id: string, options?: events.OnEventOptions): events.Rule;\n\n  /**\n   * Defines a CloudWatch event rule triggered when this job moves to the FAILED state.\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types\n   */\n  onFailure(id: string, options?: events.OnEventOptions): events.Rule;\n\n  /**\n   * Defines a CloudWatch event rule triggered when this job moves to the TIMEOUT state.\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types\n   */\n  onTimeout(id: string, options?: events.OnEventOptions): events.Rule;\n\n  /**\n   * Create a CloudWatch metric.\n   *\n   * @param metricName name of the metric typically prefixed with `glue.driver.`, `glue.<executorId>.` or `glue.ALL.`.\n   * @param type the metric type.\n   * @param props metric options.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html\n   */\n  metric(metricName: string, type: MetricType, props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Create a CloudWatch Metric indicating job success.\n   */\n  metricSuccess(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Create a CloudWatch Metric indicating job failure.\n   */\n  metricFailure(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Create a CloudWatch Metric indicating job timeout.\n   */\n  metricTimeout(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n}\n\n/**\n * Properties for enabling Continuous Logging for Glue Jobs.\n *\n * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging-enable.html\n * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n */\nexport interface ContinuousLoggingProps {\n  /**\n   * Enable continuous logging.\n   */\n  readonly enabled: boolean;\n\n  /**\n   * Specify a custom CloudWatch log group name.\n   *\n   * @default - a log group is created with name `/aws-glue/jobs/logs-v2/`.\n   */\n  readonly logGroup?: logs.ILogGroup;\n\n  /**\n   * Specify a custom CloudWatch log stream prefix.\n   *\n   * @default - the job run ID.\n   */\n  readonly logStreamPrefix?: string;\n\n  /**\n   * Filter out non-useful Apache Spark driver/executor and Apache Hadoop YARN heartbeat log messages.\n   *\n   * @default true\n   */\n  readonly quiet?: boolean;\n\n  /**\n   * Apply the provided conversion pattern.\n   *\n   * This is a Log4j Conversion Pattern to customize driver and executor logs.\n   *\n   * @default `%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n`\n   */\n  readonly conversionPattern?: string;\n}\n\n/**\n * A base class is needed to be able to import existing Jobs into a CDK app to\n * reference as part of a larger stack or construct. JobBase has the subset\n * of attributes required to identify and reference an existing Glue Job,\n * as well as some CloudWatch metric convenience functions to configure an\n * event-driven flow using the job.\n */\nexport abstract class JobBase extends cdk.Resource implements IJob {\n  public abstract readonly jobArn: string;\n  public abstract readonly jobName: string;\n  public abstract readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * Create a CloudWatch Event Rule for this Glue Job when it's in a given state\n   *\n   * @param id construct id\n   * @param options event options. Note that some values are overridden if provided, these are\n   *  - eventPattern.source = ['aws.glue']\n   *  - eventPattern.detailType = ['Glue Job State Change', 'Glue Job Run Status']\n   *  - eventPattern.detail.jobName = [this.jobName]\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types\n   */\n  public onEvent(id: string, options: events.OnEventOptions = {}): events.Rule {\n    const rule = new events.Rule(this, id, options);\n    rule.addTarget(options.target);\n    rule.addEventPattern({\n      source: ['aws.glue'],\n      detailType: ['Glue Job State Change', 'Glue Job Run Status'],\n      detail: {\n        jobName: [this.jobName],\n      },\n    });\n    return rule;\n  }\n\n  /**\n   * Create a CloudWatch Event Rule for the transition into the input jobState.\n   *\n   * @param id construct id.\n   * @param jobState the job state.\n   * @param options optional event options.\n   */\n  protected onStateChange(id: string, jobState: JobState, options: events.OnEventOptions = {}): events.Rule {\n    const rule = this.onEvent(id, {\n      description: `Rule triggered when Glue job ${this.jobName} is in ${jobState} state`,\n      ...options,\n    });\n    rule.addEventPattern({\n      detail: {\n        state: [jobState],\n      },\n    });\n    return rule;\n  }\n\n  /**\n   * Create a CloudWatch Event Rule matching JobState.SUCCEEDED.\n   *\n   * @param id construct id.\n   * @param options optional event options. default is {}.\n   */\n  public onSuccess(id: string, options: events.OnEventOptions = {}): events.Rule {\n    return this.onStateChange(id, JobState.SUCCEEDED, options);\n  }\n\n  /**\n   * Return a CloudWatch Event Rule matching FAILED state.\n   *\n   * @param id construct id.\n   * @param options optional event options. default is {}.\n   */\n  public onFailure(id: string, options: events.OnEventOptions = {}): events.Rule {\n    return this.onStateChange(id, JobState.FAILED, options);\n  }\n\n  /**\n   * Return a CloudWatch Event Rule matching TIMEOUT state.\n   *\n   * @param id construct id.\n   * @param options optional event options. default is {}.\n   */\n  public onTimeout(id: string, options: events.OnEventOptions = {}): events.Rule {\n    return this.onStateChange(id, JobState.TIMEOUT, options);\n  }\n\n  /**\n   * Create a CloudWatch metric.\n   *\n   * @param metricName name of the metric typically prefixed with `glue.driver.`, `glue.<executorId>.` or `glue.ALL.`.\n   * @param type the metric type.\n   * @param props metric options.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html\n   */\n  public metric(metricName: string, type: MetricType, props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      metricName,\n      namespace: 'Glue',\n      dimensionsMap: {\n        JobName: this.jobName,\n        JobRunId: 'ALL',\n        Type: type,\n      },\n      ...props,\n    }).attachTo(this);\n  }\n\n  /**\n   * Return a CloudWatch Metric indicating job success.\n   *\n   * This metric is based on the Rule returned by no-args onSuccess() call.\n   */\n  public metricSuccess(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return metricRule(this.metricJobStateRule('SuccessMetricRule', JobState.SUCCEEDED), props);\n  }\n\n  /**\n   * Return a CloudWatch Metric indicating job failure.\n   *\n   * This metric is based on the Rule returned by no-args onFailure() call.\n   */\n  public metricFailure(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return metricRule(this.metricJobStateRule('FailureMetricRule', JobState.FAILED), props);\n  }\n\n  /**\n   * Return a CloudWatch Metric indicating job timeout.\n   *\n   * This metric is based on the Rule returned by no-args onTimeout() call.\n   */\n  public metricTimeout(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return metricRule(this.metricJobStateRule('TimeoutMetricRule', JobState.TIMEOUT), props);\n  }\n\n  /**\n   * Creates or retrieves a singleton event rule for the input job state for use with the metric JobState methods.\n   *\n   * @param id construct id.\n   * @param jobState the job state.\n   */\n  private metricJobStateRule(id: string, jobState: JobState): events.Rule {\n    return this.node.tryFindChild(id) as events.Rule ?? this.onStateChange(id, jobState);\n  }\n\n  /**\n   * Returns the job arn\n   */\n  protected buildJobArn(scope: constructs.Construct, jobName: string) : string {\n    return cdk.Stack.of(scope).formatArn({\n      service: 'glue',\n      resource: 'job',\n      resourceName: jobName,\n    });\n  }\n}\n\n/**\n * A subset of Job attributes are required for importing an existing job\n * into a CDK project. This is only used when using fromJobAttributes\n * to identify and reference the existing job.\n */\nexport interface JobAttributes {\n  /**\n   * The name of the job.\n   */\n  readonly jobName: string;\n\n  /**\n   * The IAM role assumed by Glue to run this job.\n   *\n   * @default - undefined\n   */\n  readonly role?: iam.IRole;\n\n}\n\n/**\n * JobProps will be used to create new Glue Jobs using this L2 Construct.\n */\nexport interface JobProps {\n  /**\n   * Script Code Location (required)\n   * Script to run when the Glue job executes. Can be uploaded\n   * from the local directory structure using fromAsset\n   * or referenced via S3 location using fromBucket\n   */\n  readonly script: Code;\n\n  /**\n   * IAM Role (required)\n   * IAM Role to use for Glue job execution\n   * Must be specified by the developer because the L2 doesn't have visibility\n   * into the actions the script(s) takes during the job execution\n   * The role must trust the Glue service principal (glue.amazonaws.com)\n   * and be granted sufficient permissions.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/getting-started-access.html\n   */\n  readonly role: iam.IRole;\n\n  /**\n   * Name of the Glue job (optional)\n   * Developer-specified name of the Glue job\n   *\n   * @default - a name is automatically generated\n   */\n  readonly jobName?: string;\n\n  /**\n   * Description (optional)\n   * Developer-specified description of the Glue job\n   *\n   * @default - no value\n   */\n  readonly description?: string;\n\n  /**\n   * Max Concurrent Runs (optional)\n   * The maximum number of runs this Glue job can concurrently run\n   *\n   * An error is returned when this threshold is reached. The maximum value\n   * you can specify is controlled by a service limit.\n   *\n   * @default 1\n   */\n  readonly maxConcurrentRuns?: number;\n\n  /**\n   * Default Arguments (optional)\n   * The default arguments for every run of this Glue job,\n   * specified as name-value pairs.\n   *\n   * These are emitted verbatim into the CloudFormation template, so avoid\n   * placing secrets here in plaintext. Pass secrets to the job at runtime\n   * through AWS Secrets Manager instead. A synthesis-time warning is emitted\n   * when an argument key looks like a credential and holds a plaintext literal.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   * for a list of reserved parameters\n   * @default - no arguments\n   */\n  readonly defaultArguments?: { [key: string]: string };\n\n  /**\n   * Connections (optional)\n   * List of connections to use for this Glue job\n   * Connections are used to connect to other AWS Service or resources within a VPC.\n   *\n   * @default [] - no connections are added to the job\n   */\n  readonly connections?: IConnection[];\n\n  /**\n   * Max Retries (optional)\n   * Maximum number of retry attempts Glue performs if the job fails\n   *\n   * @default 0\n   */\n  readonly maxRetries?: number;\n\n  /**\n   * Timeout (optional)\n   * The maximum time that a job run can consume resources before it is\n   * terminated and enters TIMEOUT status. Specified in minutes.\n   *\n   * @default 2880 (2 days for non-streaming)\n   *\n   */\n  readonly timeout?: cdk.Duration;\n\n  /**\n   * Security Configuration (optional)\n   * Defines the encryption options for the Glue job\n   *\n   * @default - no security configuration.\n   */\n  readonly securityConfiguration?: ISecurityConfiguration;\n\n  /**\n   * Tags (optional)\n   * A list of key:value pairs of tags to apply to this Glue job resources\n   *\n   * @default {} - no tags\n   */\n  readonly tags?: { [key: string]: string };\n\n  /**\n   * Glue Version\n   * The version of Glue to use to execute this job\n   *\n   * @default - determined by the job type: 4.0 for ETL and Streaming, 5.0 for Flex, 3.0 for Python Shell\n   */\n  readonly glueVersion?: GlueVersion;\n\n  /**\n   * Enables continuous logging with the specified props.\n   *\n   * @default - continuous logging is enabled.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging-enable.html\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   **/\n  readonly continuousLogging?: ContinuousLoggingProps;\n}\n\n/**\n * A Glue Job.\n * @resource AWS::Glue::Job\n */\nexport abstract class Job extends JobBase {\n  /**\n   * Identifies an existing Glue Job from a subset of attributes that can\n   * be referenced from within another Stack or Construct.\n   *\n   * @param scope The scope creating construct (usually `this`)\n   * @param id The construct's id.\n   * @param attrs Attributes for the Glue Job we want to import\n   */\n  public static fromJobAttributes(scope: constructs.Construct, id: string, attrs: JobAttributes): IJob {\n    class Import extends JobBase {\n      public readonly jobName = attrs.jobName;\n      public readonly jobArn = this.buildJobArn(scope, attrs.jobName);\n      public readonly grantPrincipal = attrs.role ?? new iam.UnknownPrincipal({ resource: this });\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * The IAM role Glue assumes to run this job.\n   */\n  public readonly abstract role: iam.IRole;\n\n  /**\n   * Check no usage of reserved arguments.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  protected checkNoReservedArgs(defaultArguments?: { [key: string]: string }) {\n    if (defaultArguments) {\n      const reservedArgs = new Set(['--debug', '--mode', '--JOB_NAME']);\n      Object.keys(defaultArguments).forEach((arg) => {\n        if (reservedArgs.has(arg)) {\n          throw new cdk.ValidationError(lit`ReservedArgumentUsed`, `The ${arg} argument is reserved by Glue. Don't set it`, this);\n        }\n      });\n    }\n    warnOnPlaintextSecrets(\n      this,\n      defaultArguments,\n      '@aws-cdk/aws-glue-alpha:plaintextJobArgumentSecret',\n      'Pass secrets to the job at runtime through AWS Secrets Manager instead of embedding them in `defaultArguments`.',\n    );\n    return defaultArguments;\n  }\n\n  /**\n   * Setup Continuous Logging Properties\n   * @param role The IAM role to use for continuous logging\n   * @param props The properties for continuous logging configuration\n   * @returns String containing the args for the continuous logging command\n   */\n  protected setupContinuousLogging(role: iam.IRole, props: ContinuousLoggingProps | undefined) : any {\n    // If the developer has explicitly disabled continuous logging return no args\n    if (props && !props.enabled) {\n      return {};\n    }\n\n    // Else we turn on continuous logging by default. Determine what log group to use.\n    const args: {[key: string]: string} = {\n      '--enable-continuous-cloudwatch-log': 'true',\n    };\n\n    if (props?.quiet) {\n      args['--enable-continuous-log-filter'] = 'true';\n    }\n\n    // If the developer provided a log group, add its name to the args and update the role.\n    if (props?.logGroup) {\n      args['--continuous-log-logGroup'] = props.logGroup.logGroupName;\n      props.logGroup.grantWrite(role);\n    }\n\n    if (props?.logStreamPrefix) {\n      args['--continuous-log-logStreamPrefix'] = props.logStreamPrefix;\n    }\n\n    if (props?.conversionPattern) {\n      args['--continuous-log-conversionPattern'] = props.conversionPattern;\n    }\n\n    return args;\n  }\n\n  protected codeS3ObjectUrl(code: Code) {\n    const s3Location = code.bind(this, this.role).s3Location;\n    return `s3://${s3Location.bucketName}/${s3Location.objectKey}`;\n  }\n}\n\n/**\n * Create a CloudWatch Metric that's based on Glue Job events\n * {@see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types}\n * The metric has namespace = 'AWS/Events', metricName = 'TriggeredRules' and RuleName = rule.ruleName dimension.\n *\n * @param rule for use in setting RuleName dimension value\n * @param props metric properties\n */\nfunction metricRule(rule: events.IRule, props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n  return new cloudwatch.Metric({\n    namespace: 'AWS/Events',\n    metricName: 'TriggeredRules',\n    dimensionsMap: { RuleName: rule.ruleName },\n    statistic: cloudwatch.Stats.SUM,\n    ...props,\n  }).attachTo(rule);\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"job.js","sourceRoot":"","sources":["job.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';\nimport * as events from 'aws-cdk-lib/aws-events';\nimport type { IJobRef, JobReference } from 'aws-cdk-lib/aws-glue';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport type * as logs from 'aws-cdk-lib/aws-logs';\nimport * as cdk from 'aws-cdk-lib/core';\nimport { lit } from 'aws-cdk-lib/core/lib/helpers-internal';\nimport type * as constructs from 'constructs';\nimport type { Code } from '../code';\nimport type { IConnection } from '../connection';\nimport type { MetricType, GlueVersion } from '../constants';\nimport { JobState } from '../constants';\nimport { warnOnPlaintextSecrets } from '../private/secret-detection';\nimport type { ISecurityConfiguration } from '../security-configuration';\n\n/**\n * Interface representing a new or an imported Glue Job\n */\nexport interface IJob extends cdk.IResource, iam.IGrantable, IJobRef {\n  /**\n   * The name of the job.\n   * @attribute\n   */\n  readonly jobName: string;\n\n  /**\n   * The ARN of the job.\n   * @attribute\n   */\n  readonly jobArn: string;\n\n  /**\n   * Defines a CloudWatch event rule triggered when something happens with this job.\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types\n   */\n  onEvent(id: string, options?: events.OnEventOptions): events.Rule;\n\n  /**\n   * Defines a CloudWatch event rule triggered when this job moves to the SUCCEEDED state.\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types\n   */\n  onSuccess(id: string, options?: events.OnEventOptions): events.Rule;\n\n  /**\n   * Defines a CloudWatch event rule triggered when this job moves to the FAILED state.\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types\n   */\n  onFailure(id: string, options?: events.OnEventOptions): events.Rule;\n\n  /**\n   * Defines a CloudWatch event rule triggered when this job moves to the TIMEOUT state.\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types\n   */\n  onTimeout(id: string, options?: events.OnEventOptions): events.Rule;\n\n  /**\n   * Create a CloudWatch metric.\n   *\n   * @param metricName name of the metric typically prefixed with `glue.driver.`, `glue.<executorId>.` or `glue.ALL.`.\n   * @param type the metric type.\n   * @param props metric options.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html\n   */\n  metric(metricName: string, type: MetricType, props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Create a CloudWatch Metric indicating job success.\n   */\n  metricSuccess(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Create a CloudWatch Metric indicating job failure.\n   */\n  metricFailure(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Create a CloudWatch Metric indicating job timeout.\n   */\n  metricTimeout(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n}\n\n/**\n * Properties for enabling Continuous Logging for Glue Jobs.\n *\n * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging-enable.html\n * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n */\nexport interface ContinuousLoggingProps {\n  /**\n   * Enable continuous logging.\n   */\n  readonly enabled: boolean;\n\n  /**\n   * Specify a custom CloudWatch log group name.\n   *\n   * @default - a log group is created with name `/aws-glue/jobs/logs-v2/`.\n   */\n  readonly logGroup?: logs.ILogGroup;\n\n  /**\n   * Specify a custom CloudWatch log stream prefix.\n   *\n   * @default - the job run ID.\n   */\n  readonly logStreamPrefix?: string;\n\n  /**\n   * Filter out non-useful Apache Spark driver/executor and Apache Hadoop YARN heartbeat log messages.\n   *\n   * @default true\n   */\n  readonly quiet?: boolean;\n\n  /**\n   * Apply the provided conversion pattern.\n   *\n   * This is a Log4j Conversion Pattern to customize driver and executor logs.\n   *\n   * @default `%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n`\n   */\n  readonly conversionPattern?: string;\n}\n\n/**\n * A base class is needed to be able to import existing Jobs into a CDK app to\n * reference as part of a larger stack or construct. JobBase has the subset\n * of attributes required to identify and reference an existing Glue Job,\n * as well as some CloudWatch metric convenience functions to configure an\n * event-driven flow using the job.\n */\nexport abstract class JobBase extends cdk.Resource implements IJob {\n  public abstract readonly jobArn: string;\n  public abstract readonly jobName: string;\n  public abstract readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * A reference to this Job resource, for use with the generated L1 ref interface.\n   */\n  public get jobRef(): JobReference {\n    return { jobName: this.jobName };\n  }\n\n  /**\n   * Create a CloudWatch Event Rule for this Glue Job when it's in a given state\n   *\n   * @param id construct id\n   * @param options event options. Note that some values are overridden if provided, these are\n   *  - eventPattern.source = ['aws.glue']\n   *  - eventPattern.detailType = ['Glue Job State Change', 'Glue Job Run Status']\n   *  - eventPattern.detail.jobName = [this.jobName]\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types\n   */\n  public onEvent(id: string, options: events.OnEventOptions = {}): events.Rule {\n    const rule = new events.Rule(this, id, options);\n    rule.addTarget(options.target);\n    rule.addEventPattern({\n      source: ['aws.glue'],\n      detailType: ['Glue Job State Change', 'Glue Job Run Status'],\n      detail: {\n        jobName: [this.jobName],\n      },\n    });\n    return rule;\n  }\n\n  /**\n   * Create a CloudWatch Event Rule for the transition into the input jobState.\n   *\n   * @param id construct id.\n   * @param jobState the job state.\n   * @param options optional event options.\n   */\n  protected onStateChange(id: string, jobState: JobState, options: events.OnEventOptions = {}): events.Rule {\n    const rule = this.onEvent(id, {\n      description: `Rule triggered when Glue job ${this.jobName} is in ${jobState} state`,\n      ...options,\n    });\n    rule.addEventPattern({\n      detail: {\n        state: [jobState],\n      },\n    });\n    return rule;\n  }\n\n  /**\n   * Create a CloudWatch Event Rule matching JobState.SUCCEEDED.\n   *\n   * @param id construct id.\n   * @param options optional event options. default is {}.\n   */\n  public onSuccess(id: string, options: events.OnEventOptions = {}): events.Rule {\n    return this.onStateChange(id, JobState.SUCCEEDED, options);\n  }\n\n  /**\n   * Return a CloudWatch Event Rule matching FAILED state.\n   *\n   * @param id construct id.\n   * @param options optional event options. default is {}.\n   */\n  public onFailure(id: string, options: events.OnEventOptions = {}): events.Rule {\n    return this.onStateChange(id, JobState.FAILED, options);\n  }\n\n  /**\n   * Return a CloudWatch Event Rule matching TIMEOUT state.\n   *\n   * @param id construct id.\n   * @param options optional event options. default is {}.\n   */\n  public onTimeout(id: string, options: events.OnEventOptions = {}): events.Rule {\n    return this.onStateChange(id, JobState.TIMEOUT, options);\n  }\n\n  /**\n   * Create a CloudWatch metric.\n   *\n   * @param metricName name of the metric typically prefixed with `glue.driver.`, `glue.<executorId>.` or `glue.ALL.`.\n   * @param type the metric type.\n   * @param props metric options.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html\n   */\n  public metric(metricName: string, type: MetricType, props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      metricName,\n      namespace: 'Glue',\n      dimensionsMap: {\n        JobName: this.jobName,\n        JobRunId: 'ALL',\n        Type: type,\n      },\n      ...props,\n    }).attachTo(this);\n  }\n\n  /**\n   * Return a CloudWatch Metric indicating job success.\n   *\n   * This metric is based on the Rule returned by no-args onSuccess() call.\n   */\n  public metricSuccess(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return metricRule(this.metricJobStateRule('SuccessMetricRule', JobState.SUCCEEDED), props);\n  }\n\n  /**\n   * Return a CloudWatch Metric indicating job failure.\n   *\n   * This metric is based on the Rule returned by no-args onFailure() call.\n   */\n  public metricFailure(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return metricRule(this.metricJobStateRule('FailureMetricRule', JobState.FAILED), props);\n  }\n\n  /**\n   * Return a CloudWatch Metric indicating job timeout.\n   *\n   * This metric is based on the Rule returned by no-args onTimeout() call.\n   */\n  public metricTimeout(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return metricRule(this.metricJobStateRule('TimeoutMetricRule', JobState.TIMEOUT), props);\n  }\n\n  /**\n   * Creates or retrieves a singleton event rule for the input job state for use with the metric JobState methods.\n   *\n   * @param id construct id.\n   * @param jobState the job state.\n   */\n  private metricJobStateRule(id: string, jobState: JobState): events.Rule {\n    return this.node.tryFindChild(id) as events.Rule ?? this.onStateChange(id, jobState);\n  }\n\n  /**\n   * Returns the job arn\n   */\n  protected buildJobArn(scope: constructs.Construct, jobName: string) : string {\n    return cdk.Stack.of(scope).formatArn({\n      service: 'glue',\n      resource: 'job',\n      resourceName: jobName,\n    });\n  }\n}\n\n/**\n * A subset of Job attributes are required for importing an existing job\n * into a CDK project. This is only used when using fromJobAttributes\n * to identify and reference the existing job.\n */\nexport interface JobAttributes {\n  /**\n   * The name of the job.\n   */\n  readonly jobName: string;\n\n  /**\n   * The IAM role assumed by Glue to run this job.\n   *\n   * @default - undefined\n   */\n  readonly role?: iam.IRole;\n\n}\n\n/**\n * JobProps will be used to create new Glue Jobs using this L2 Construct.\n */\nexport interface JobProps {\n  /**\n   * Script Code Location (required)\n   * Script to run when the Glue job executes. Can be uploaded\n   * from the local directory structure using fromAsset\n   * or referenced via S3 location using fromBucket\n   */\n  readonly script: Code;\n\n  /**\n   * IAM Role (required)\n   * IAM Role to use for Glue job execution\n   * Must be specified by the developer because the L2 doesn't have visibility\n   * into the actions the script(s) takes during the job execution\n   * The role must trust the Glue service principal (glue.amazonaws.com)\n   * and be granted sufficient permissions.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/getting-started-access.html\n   */\n  readonly role: iam.IRole;\n\n  /**\n   * Name of the Glue job (optional)\n   * Developer-specified name of the Glue job\n   *\n   * @default - a name is automatically generated\n   */\n  readonly jobName?: string;\n\n  /**\n   * Description (optional)\n   * Developer-specified description of the Glue job\n   *\n   * @default - no value\n   */\n  readonly description?: string;\n\n  /**\n   * Max Concurrent Runs (optional)\n   * The maximum number of runs this Glue job can concurrently run\n   *\n   * An error is returned when this threshold is reached. The maximum value\n   * you can specify is controlled by a service limit.\n   *\n   * @default 1\n   */\n  readonly maxConcurrentRuns?: number;\n\n  /**\n   * Default Arguments (optional)\n   * The default arguments for every run of this Glue job,\n   * specified as name-value pairs.\n   *\n   * This map is the escape hatch for Glue job arguments that this construct does not model. It\n   * MUST NOT be used to set arguments that already have a dedicated prop — configure those through\n   * the corresponding prop instead (`continuousLogging`, `enableMetrics`,\n   * `enableObservabilityMetrics`, `sparkUI`, `className`, `extraJars`, `extraJarsFirst`,\n   * `extraPythonFiles`, `extraFiles`). Passing a construct-managed argument (e.g.\n   * `--enable-continuous-cloudwatch-log`, `--enable-metrics`, `--enable-spark-ui`,\n   * `--job-language`) or a Glue-reserved argument (`--debug`, `--mode`, `--JOB_NAME`, `--endpoint`)\n   * here throws at synthesis time, so there is exactly one way to express each intent.\n   *\n   * Also note that these are emitted verbatim into the CloudFormation template, so avoid\n   * placing secrets here in plaintext. Pass secrets to the job at runtime\n   * through AWS Secrets Manager instead. A synthesis-time warning is emitted\n   * when an argument key looks like a credential and holds a plaintext literal.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   * for a list of reserved parameters\n   * @default - no arguments\n   */\n  readonly defaultArguments?: { [key: string]: string };\n\n  /**\n   * Connections (optional)\n   * List of connections to use for this Glue job\n   * Connections are used to connect to other AWS Service or resources within a VPC.\n   *\n   * @default [] - no connections are added to the job\n   */\n  readonly connections?: IConnection[];\n\n  /**\n   * Max Retries (optional)\n   * Maximum number of retry attempts Glue performs if the job fails\n   *\n   * @default 0\n   */\n  readonly maxRetries?: number;\n\n  /**\n   * Timeout (optional)\n   * The maximum time that a job run can consume resources before it is\n   * terminated and enters TIMEOUT status. Specified in minutes.\n   *\n   * @default 2880 (2 days for non-streaming)\n   *\n   */\n  readonly timeout?: cdk.Duration;\n\n  /**\n   * Security Configuration (optional)\n   * Defines the encryption options for the Glue job\n   *\n   * @default - no security configuration.\n   */\n  readonly securityConfiguration?: ISecurityConfiguration;\n\n  /**\n   * Tags (optional)\n   * A list of key:value pairs of tags to apply to this Glue job resources\n   *\n   * @default {} - no tags\n   */\n  readonly tags?: { [key: string]: string };\n\n  /**\n   * Glue Version\n   * The version of Glue to use to execute this job\n   *\n   * @default - determined by the job type: 4.0 for ETL and Streaming, 5.0 for Flex, 3.0 for Python Shell\n   */\n  readonly glueVersion?: GlueVersion;\n\n  /**\n   * Enables continuous logging with the specified props.\n   *\n   * @default - continuous logging is enabled.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging-enable.html\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   **/\n  readonly continuousLogging?: ContinuousLoggingProps;\n}\n\n/**\n * A Glue Job.\n * @resource AWS::Glue::Job\n */\nexport abstract class Job extends JobBase {\n  /**\n   * Identifies an existing Glue Job from a subset of attributes that can\n   * be referenced from within another Stack or Construct.\n   *\n   * @param scope The scope creating construct (usually `this`)\n   * @param id The construct's id.\n   * @param attrs Attributes for the Glue Job we want to import\n   */\n  public static fromJobAttributes(scope: constructs.Construct, id: string, attrs: JobAttributes): IJob {\n    class Import extends JobBase {\n      public readonly jobName = attrs.jobName;\n      public readonly jobArn = this.buildJobArn(scope, attrs.jobName);\n      public readonly grantPrincipal = attrs.role ?? new iam.UnknownPrincipal({ resource: this });\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * Argument keys that Glue reserves for its own use and that a caller must never set through\n   * `defaultArguments`. Unlike construct-managed arguments (which are derived from what each job\n   * class emits), these are owned by the Glue service itself and are reserved for every job type.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  private static readonly GLUE_RESERVED_ARGUMENTS = new Set(['--debug', '--mode', '--JOB_NAME', '--endpoint']);\n\n  /**\n   * The IAM role Glue assumes to run this job.\n   */\n  public readonly abstract role: iam.IRole;\n\n  /**\n   * The construct-managed job arguments that are actually emitted for the current configuration,\n   * accumulated via {@link setManagedArgument}. Passed through to `CfnJob.defaultArguments` after\n   * being merged with the user-supplied `defaultArguments` by {@link mergeDefaultArguments}.\n   */\n  private readonly _managedArguments: { [key: string]: string } = {};\n\n  /**\n   * Every argument key this construct manages, accumulated via {@link setManagedArgument} — whether\n   * or not the current configuration emits a value for it. This is the reserved set that a\n   * user-supplied `defaultArguments` must not collide with. Registering a key even when its value\n   * is `undefined` (feature disabled or unset) is what keeps `defaultArguments` from silently\n   * re-enabling it.\n   */\n  private readonly _managedArgumentKeys = new Set<string>();\n\n  /**\n   * Declare `key` as construct-managed and, when `value` is defined, emit it into the job's\n   * arguments.\n   *\n   * This is the single sink for every argument a job construct derives from its typed props (or\n   * from the job class itself). Call it once per managed key, passing `undefined` as the value when\n   * the corresponding feature is turned off or unset — the key is still reserved from\n   * `defaultArguments` either way, so a disabled feature cannot be re-enabled through the escape\n   * hatch. There is deliberately no other way for a subclass to emit a managed argument, so the\n   * reserved set can never drift from what is emitted.\n   *\n   * @param key the Glue argument key, e.g. `--enable-metrics`\n   * @param value the value to emit, or `undefined` to reserve the key without emitting it\n   */\n  protected setManagedArgument(key: string, value?: string): void {\n    this._managedArgumentKeys.add(key);\n    if (value !== undefined) {\n      this._managedArguments[key] = value;\n    }\n  }\n\n  /**\n   * Merge the customer-supplied `defaultArguments` with the arguments this construct manages.\n   *\n   * The construct owns every argument it emits — whether the value comes from a dedicated typed\n   * prop (e.g. `continuousLogging`, `enableMetrics`, `sparkUI`) or from the job class itself\n   * (e.g. `--job-language`). Those arguments, plus the arguments Glue reserves for its own use,\n   * MUST be configured through their dedicated props rather than the untyped `defaultArguments`\n   * map, so there is exactly one way to express each intent. Passing such a key through\n   * `defaultArguments` therefore throws instead of silently winning or being silently dropped.\n   *\n   * A managed key whose supplied value is identical to the construct's value is not contradictory,\n   * so it is allowed rather than rejected (auto-correcting config is preferred over errors).\n   * Glue-reserved keys are never emitted by the construct, so there is no value to reconcile and\n   * they always throw.\n   *\n   * The reserved set is `_managedArgumentKeys` — every key the construct declared through\n   * {@link setManagedArgument}, whether or not a value was emitted for it. It is deliberately NOT\n   * derived from the keys that carry a value: a typed prop that turns a feature *off* (e.g.\n   * `enableMetrics: false`) emits no value but still reserves its key, so `defaultArguments` cannot\n   * silently re-enable it.\n   *\n   * Conflict detection relies on string equality of the argument keys, which cannot see through\n   * unresolved tokens (e.g. a key produced by `CfnJson` that only resolves at deploy time). If a\n   * key is a token, the check is skipped for that key and a synthesis-time warning is emitted, so\n   * the (rare) case where a token key resolves to a managed argument at deploy time — in which the\n   * construct-managed value would silently take precedence — is surfaced rather than hidden.\n   *\n   * @param defaultArguments the caller-supplied escape-hatch arguments, if any\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  protected mergeDefaultArguments(\n    defaultArguments?: { [key: string]: string },\n  ): { [key: string]: string } {\n    if (defaultArguments) {\n      if (Object.keys(defaultArguments).some((arg) => cdk.Token.isUnresolved(arg))) {\n        cdk.Annotations.of(this).addWarningV2(\n          '@aws-cdk/aws-glue-alpha:tokenJobArgumentKey',\n          'defaultArguments contains an unresolved token as an argument key, so it cannot be checked for conflicts with construct-managed arguments. If it resolves to a managed argument at deploy time, the construct-managed value will take precedence. Configure managed arguments through their dedicated props (e.g. continuousLogging, enableMetrics, enableObservabilityMetrics, sparkUI).',\n        );\n      }\n      const conflicts = Object.keys(defaultArguments).filter(\n        (arg) => Job.GLUE_RESERVED_ARGUMENTS.has(arg)\n          || (this._managedArgumentKeys.has(arg)\n            && !(Object.hasOwn(this._managedArguments, arg) && defaultArguments[arg] === this._managedArguments[arg])),\n      );\n      if (conflicts.length > 0) {\n        throw new cdk.ValidationError(\n          lit`ManagedJobArgument`,\n          `the job argument(s) ${JSON.stringify(conflicts)} are managed by the construct or reserved by Glue; configure them through the corresponding props (e.g. continuousLogging, enableMetrics, enableObservabilityMetrics, sparkUI) instead of defaultArguments`,\n          this,\n        );\n      }\n    }\n    warnOnPlaintextSecrets(\n      this,\n      defaultArguments,\n      '@aws-cdk/aws-glue-alpha:plaintextJobArgumentSecret',\n      'Pass secrets to the job at runtime through AWS Secrets Manager instead of embedding them in `defaultArguments`.',\n    );\n    return { ...defaultArguments, ...this._managedArguments };\n  }\n\n  /**\n   * Register (and, when enabled, emit) the continuous-logging arguments this job manages.\n   *\n   * All five continuous-logging keys are reserved on every job type regardless of configuration:\n   * they are always registered through {@link setManagedArgument}, and carry a value only when\n   * logging is enabled. This keeps `defaultArguments` from re-enabling logging a user turned off.\n   *\n   * @param role The IAM role to grant write access to a custom log group, if one is provided\n   * @param props The properties for continuous logging configuration\n   * @param securityConfiguration The security configuration attached to the job, if any\n   */\n  protected setupContinuousLogging(role: iam.IRole, props: ContinuousLoggingProps | undefined, securityConfiguration?: ISecurityConfiguration): void {\n    // Continuous logging is on unless the developer has explicitly disabled it.\n    const enabled = !(props && !props.enabled);\n\n    // When logging is on, the logs are written to an unencrypted CloudWatch log group unless a\n    // SecurityConfiguration is attached. We cannot introspect whether the attached\n    // SecurityConfiguration actually configures cloudWatchEncryption (the ISecurityConfiguration\n    // interface only exposes the name), so we only warn when none is attached at all to avoid\n    // false positives.\n    if (enabled && !securityConfiguration) {\n      cdk.Annotations.of(this).addWarningV2(\n        '@aws-cdk/aws-glue-alpha:unencryptedContinuousLogging',\n        'Continuous CloudWatch logging is enabled but no SecurityConfiguration with cloudWatchEncryption is attached. Job stdout and stderr will be written to an unencrypted CloudWatch log group. See https://docs.aws.amazon.com/glue/latest/dg/encryption-security-configuration.html',\n      );\n    }\n\n    // A custom log group is only wired up (and only granted write) when logging is enabled.\n    const logGroup = enabled ? props?.logGroup : undefined;\n    logGroup?.grantWrite(role);\n\n    this.setManagedArgument('--enable-continuous-cloudwatch-log', enabled ? 'true' : undefined);\n    this.setManagedArgument('--enable-continuous-log-filter', enabled && props?.quiet ? 'true' : undefined);\n    this.setManagedArgument('--continuous-log-logGroup', logGroup?.logGroupName);\n    this.setManagedArgument('--continuous-log-logStreamPrefix', enabled ? props?.logStreamPrefix : undefined);\n    this.setManagedArgument('--continuous-log-conversionPattern', enabled ? props?.conversionPattern : undefined);\n  }\n\n  protected codeS3ObjectUrl(code: Code) {\n    const s3Location = code.bind(this, this.role).s3Location;\n    return `s3://${s3Location.bucketName}/${s3Location.objectKey}`;\n  }\n}\n\n/**\n * Create a CloudWatch Metric that's based on Glue Job events\n * {@see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types}\n * The metric has namespace = 'AWS/Events', metricName = 'TriggeredRules' and RuleName = rule.ruleName dimension.\n *\n * @param rule for use in setting RuleName dimension value\n * @param props metric properties\n */\nfunction metricRule(rule: events.IRule, props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n  return new cloudwatch.Metric({\n    namespace: 'AWS/Events',\n    metricName: 'TriggeredRules',\n    dimensionsMap: { RuleName: rule.ruleName },\n    statistic: cloudwatch.Stats.SUM,\n    ...props,\n  }).attachTo(rule);\n}\n\n"]}

package/lib/jobs/pyspark-etl-job.d.ts

@@ -78,9 +78,7 @@ export declare class PySparkEtlJob extends SparkJob {
     get jobArn(): string;
     get jobName(): string;
     /**
-     * Set the executable arguments with best practices enabled by default
-     *
-     * @returns An array of arguments for Glue to use on execution
+     * Register the executable arguments with best practices enabled by default.
      */
     private executableArguments;
 }