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

package/lib/jobs/job.d.ts

@@ -1,5 +1,6 @@
 import * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';
 import * as events from 'aws-cdk-lib/aws-events';
+import type { IJobRef, JobReference } from 'aws-cdk-lib/aws-glue';
 import * as iam from 'aws-cdk-lib/aws-iam';
 import type * as logs from 'aws-cdk-lib/aws-logs';
 import * as cdk from 'aws-cdk-lib/core';
@@ -12,7 +13,7 @@ import type { ISecurityConfiguration } from '../security-configuration';
 /**
  * Interface representing a new or an imported Glue Job
  */
-export interface IJob extends cdk.IResource, iam.IGrantable {
+export interface IJob extends cdk.IResource, iam.IGrantable, IJobRef {
     /**
      * The name of the job.
      * @attribute
@@ -119,6 +120,10 @@ export declare abstract class JobBase extends cdk.Resource implements IJob {
     abstract readonly jobArn: string;
     abstract readonly jobName: string;
     abstract readonly grantPrincipal: iam.IPrincipal;
+    /**
+     * A reference to this Job resource, for use with the generated L1 ref interface.
+     */
+    get jobRef(): JobReference;
     /**
      * Create a CloudWatch Event Rule for this Glue Job when it's in a given state
      *
@@ -268,7 +273,16 @@ export interface JobProps {
      * The default arguments for every run of this Glue job,
      * specified as name-value pairs.
      *
-     * These are emitted verbatim into the CloudFormation template, so avoid
+     * This map is the escape hatch for Glue job arguments that this construct does not model. It
+     * MUST NOT be used to set arguments that already have a dedicated prop — configure those through
+     * the corresponding prop instead (`continuousLogging`, `enableMetrics`,
+     * `enableObservabilityMetrics`, `sparkUI`, `className`, `extraJars`, `extraJarsFirst`,
+     * `extraPythonFiles`, `extraFiles`). Passing a construct-managed argument (e.g.
+     * `--enable-continuous-cloudwatch-log`, `--enable-metrics`, `--enable-spark-ui`,
+     * `--job-language`) or a Glue-reserved argument (`--debug`, `--mode`, `--JOB_NAME`, `--endpoint`)
+     * here throws at synthesis time, so there is exactly one way to express each intent.
+     *
+     * Also note that these are emitted verbatim into the CloudFormation template, so avoid
      * placing secrets here in plaintext. Pass secrets to the job at runtime
      * through AWS Secrets Manager instead. A synthesis-time warning is emitted
      * when an argument key looks like a credential and holds a plaintext literal.
@@ -351,26 +365,93 @@ export declare abstract class Job extends JobBase {
      * @param attrs Attributes for the Glue Job we want to import
      */
     static fromJobAttributes(scope: constructs.Construct, id: string, attrs: JobAttributes): IJob;
+    /**
+     * 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
+     */
+    private static readonly GLUE_RESERVED_ARGUMENTS;
     /**
      * The IAM role Glue assumes to run this job.
      */
     abstract readonly role: iam.IRole;
     /**
-     * Check no usage of reserved arguments.
+     * 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}.
+     */
+    private readonly _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.
+     */
+    private readonly _managedArgumentKeys;
+    /**
+     * 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
+     */
+    protected setManagedArgument(key: string, value?: string): void;
+    /**
+     * 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
      */
-    protected checkNoReservedArgs(defaultArguments?: {
+    protected mergeDefaultArguments(defaultArguments?: {
         [key: string]: string;
     }): {
         [key: string]: string;
-    } | undefined;
+    };
     /**
-     * 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
      */
-    protected setupContinuousLogging(role: iam.IRole, props: ContinuousLoggingProps | undefined): any;
+    protected setupContinuousLogging(role: iam.IRole, props: ContinuousLoggingProps | undefined, securityConfiguration?: ISecurityConfiguration): void;
     protected codeS3ObjectUrl(code: Code): string;
 }

package/lib/jobs/job.js

@@ -51,7 +51,13 @@ 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.269.0-alpha.0" };
+    /**
+     * A reference to this Job resource, for use with the generated L1 ref interface.
+     */
+    get jobRef() {
+        return { jobName: this.jobName };
+    }
     /**
      * Create a CloudWatch Event Rule for this Glue Job when it's in a given state
      *
@@ -210,7 +216,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.269.0-alpha.0" };
     /**
      * Identifies an existing Glue Job from a subset of attributes that can
      * be referenced from within another Stack or Construct.
@@ -237,31 +243,107 @@ 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
+     */
+    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) {
+        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
      */
-    checkNoReservedArgs(defaultArguments) {
+    mergeDefaultArguments(defaultArguments) {
         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._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,29 +351,24 @@ 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 {
@@ -325,4 +402,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;
 }

package/lib/jobs/pyspark-etl-job.js

@@ -78,7 +78,7 @@ let PySparkEtlJob = (() => {
             PySparkEtlJob = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-glue-alpha.PySparkEtlJob", version: "2.268.0-alpha.0" };
+        static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-glue-alpha.PySparkEtlJob", version: "2.269.0-alpha.0" };
         /** Uniquely identifies this class. */
         static PROPERTY_INJECTION_ID = '@aws-cdk.aws-glue-alpha.PySparkEtlJob';
         resource = __runInitializers(this, _instanceExtraInitializers);
@@ -98,11 +98,10 @@ let PySparkEtlJob = (() => {
             }
             // Enhanced CDK Analytics Telemetry
             (0, metadata_resource_1.addConstructMetadata)(this, props);
-            // Combine command line arguments into a single line item
-            const defaultArguments = {
-                ...this.executableArguments(props),
-                ...this.nonExecutableCommonArguments(props),
-            };
+            // Register the construct-managed arguments, then merge in the user's escape-hatch arguments.
+            this.executableArguments(props);
+            this.nonExecutableCommonArguments(props);
+            const defaultArguments = this.mergeDefaultArguments(props.defaultArguments);
             if (props.jobRunQueuingEnabled === true && props.maxRetries !== undefined && props.maxRetries > 0) {
                 core_1.Annotations.of(this).addWarningV2((0, helpers_internal_1.lit) `GlueMaxRetriesQueuingEnabled`, `maxRetries was set to ${props.maxRetries}. Overriding it to 0 with since job run queuing is enabled (service constraint)`);
             }
@@ -136,15 +135,11 @@ let PySparkEtlJob = (() => {
             return this.getResourceNameAttribute(this.resource.ref);
         }
         /**
-         * 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.
          */
         executableArguments(props) {
-            const args = {};
-            args['--job-language'] = constants_1.JobLanguage.PYTHON;
-            this.setupExtraCodeArguments(args, props);
-            return args;
+            this.setManagedArgument('--job-language', constants_1.JobLanguage.PYTHON);
+            this.setupExtraCodeArguments(props);
         }
         static {
             __runInitializers(_classThis, _classExtraInitializers);
@@ -153,4 +148,4 @@ let PySparkEtlJob = (() => {
     return PySparkEtlJob = _classThis;
 })();
 exports.PySparkEtlJob = PySparkEtlJob;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pyspark-etl-job.js","sourceRoot":"","sources":["pyspark-etl-job.ts"],"names":[],"mappings":"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","sourcesContent":["import { CfnJob } from 'aws-cdk-lib/aws-glue';\nimport type * as cdk from 'aws-cdk-lib/core';\nimport { Annotations } from 'aws-cdk-lib/core';\nimport { lit, memoizedGetter } from 'aws-cdk-lib/core/lib/helpers-internal';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\nimport type { Construct } from 'constructs';\nimport type { Code } from '../code';\nimport { JobType, GlueVersion, JobLanguage, PythonVersion, WorkerType } from '../constants';\nimport type { SparkJobProps } from './spark-job';\nimport { SparkJob } from './spark-job';\n\n/**\n * Properties for creating a Python Spark ETL job\n */\nexport interface PySparkEtlJobProps extends SparkJobProps {\n  /**\n   * Specifies configuration properties of a notification (optional).\n   * After a job run starts, the number of minutes to wait before sending a job run delay notification.\n   * @default - undefined\n   */\n  readonly notifyDelayAfter?: cdk.Duration;\n\n  /**\n   * Extra Python Files S3 URL (optional)\n   * S3 URL where additional python dependencies are located\n   *\n   * @default - no extra files\n   */\n  readonly extraPythonFiles?: Code[];\n\n  /**\n   * Additional files, such as configuration files that AWS Glue copies to the working directory of your script before executing it.\n   *\n   * @default - no extra files specified.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  readonly extraFiles?: Code[];\n\n  /**\n   * Extra Jars S3 URL (optional)\n   * S3 URL where additional jar dependencies are located\n   * @default - no extra jar files\n   */\n  readonly extraJars?: Code[];\n\n  /**\n   * Setting this value to true prioritizes the customer's extra JAR files in the classpath.\n   *\n   * @default false - priority is not given to user-provided jars\n   *\n   * @see `--user-jars-first` in https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  readonly extraJarsFirst?: boolean;\n\n  /**\n   * Specifies whether job run queuing is enabled for the job runs for this job.\n   * A value of true means job run queuing is enabled for the job runs.\n   * If false or not populated, the job runs will not be considered for queueing.\n   * If this field does not match the value set in the job run, then the value from\n   * the job run field will be used. This property must be set to false for flex jobs.\n   * If this property is enabled, maxRetries must be set to zero.\n   *\n   * @default false\n   */\n  readonly jobRunQueuingEnabled?: boolean;\n}\n\n/**\n * PySpark ETL Jobs class\n *\n * ETL jobs support pySpark and Scala languages, for which there are separate\n * but similar constructors. ETL jobs default to the G1 worker type, but you\n * can override this default with other supported worker type values\n * (G1, G2, G4 and G8). ETL jobs defaults to Glue version 4.0, which you can\n * override to 3.0. The following ETL features are enabled by default:\n * --enable-metrics, --enable-continuous-cloudwatch-log. The Spark UI\n * (--enable-spark-ui) is off by default; enable it by setting the `sparkUI` prop.\n * You can find more details about version, worker type and other features\n * in Glue's public documentation.\n */\n@propertyInjectable\nexport class PySparkEtlJob extends SparkJob {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-glue-alpha.PySparkEtlJob';\n  private resource: CfnJob;\n\n  /**\n   * PySparkEtlJob constructor\n   */\n  constructor(scope: Construct, id: string, props: PySparkEtlJobProps) {\n    super(scope, id, props);\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    // Combine command line arguments into a single line item\n    const defaultArguments = {\n      ...this.executableArguments(props),\n      ...this.nonExecutableCommonArguments(props),\n    };\n\n    if (props.jobRunQueuingEnabled === true && props.maxRetries !== undefined && props.maxRetries > 0) {\n      Annotations.of(this).addWarningV2(lit`GlueMaxRetriesQueuingEnabled`,\n        `maxRetries was set to ${props.maxRetries}. Overriding it to 0 with since job run queuing is enabled (service constraint)`);\n    }\n\n    this.resource = new CfnJob(this, 'Resource', {\n      name: props.jobName,\n      description: props.description,\n      role: this.role.roleArn,\n      command: {\n        name: JobType.ETL,\n        scriptLocation: this.codeS3ObjectUrl(props.script),\n        pythonVersion: PythonVersion.THREE,\n      },\n      glueVersion: props.glueVersion ?? GlueVersion.V4_0,\n      workerType: props.workerConfiguration?.workerType ?? WorkerType.G_1X,\n      numberOfWorkers: props.workerConfiguration?.numberOfWorkers ?? 10,\n      maxRetries: props.jobRunQueuingEnabled ? 0 : props.maxRetries,\n      jobRunQueuingEnabled: props.jobRunQueuingEnabled ? props.jobRunQueuingEnabled : false,\n      notificationProperty: props.notifyDelayAfter ? { notifyDelayAfter: props.notifyDelayAfter.toMinutes() } : undefined,\n      executionProperty: props.maxConcurrentRuns ? { maxConcurrentRuns: props.maxConcurrentRuns } : undefined,\n      timeout: props.timeout?.toMinutes(),\n      connections: props.connections ? { connections: props.connections.map((connection) => connection.connectionName) } : undefined,\n      securityConfiguration: props.securityConfiguration?.securityConfigurationName,\n      tags: props.tags,\n      defaultArguments,\n    });\n  }\n\n  @memoizedGetter\n  public get jobArn(): string {\n    return this.buildJobArn(this, this.jobName);\n  }\n\n  @memoizedGetter\n  public get jobName(): string {\n    return this.getResourceNameAttribute(this.resource.ref);\n  }\n\n  /**\n   * Set the executable arguments with best practices enabled by default\n   *\n   * @returns An array of arguments for Glue to use on execution\n   */\n  private executableArguments(props: PySparkEtlJobProps) {\n    const args: { [key: string]: string } = {};\n    args['--job-language'] = JobLanguage.PYTHON;\n    this.setupExtraCodeArguments(args, props);\n    return args;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pyspark-etl-job.js","sourceRoot":"","sources":["pyspark-etl-job.ts"],"names":[],"mappings":"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","sourcesContent":["import { CfnJob } from 'aws-cdk-lib/aws-glue';\nimport type * as cdk from 'aws-cdk-lib/core';\nimport { Annotations } from 'aws-cdk-lib/core';\nimport { lit, memoizedGetter } from 'aws-cdk-lib/core/lib/helpers-internal';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\nimport type { Construct } from 'constructs';\nimport type { Code } from '../code';\nimport { JobType, GlueVersion, JobLanguage, PythonVersion, WorkerType } from '../constants';\nimport type { SparkJobProps } from './spark-job';\nimport { SparkJob } from './spark-job';\n\n/**\n * Properties for creating a Python Spark ETL job\n */\nexport interface PySparkEtlJobProps extends SparkJobProps {\n  /**\n   * Specifies configuration properties of a notification (optional).\n   * After a job run starts, the number of minutes to wait before sending a job run delay notification.\n   * @default - undefined\n   */\n  readonly notifyDelayAfter?: cdk.Duration;\n\n  /**\n   * Extra Python Files S3 URL (optional)\n   * S3 URL where additional python dependencies are located\n   *\n   * @default - no extra files\n   */\n  readonly extraPythonFiles?: Code[];\n\n  /**\n   * Additional files, such as configuration files that AWS Glue copies to the working directory of your script before executing it.\n   *\n   * @default - no extra files specified.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  readonly extraFiles?: Code[];\n\n  /**\n   * Extra Jars S3 URL (optional)\n   * S3 URL where additional jar dependencies are located\n   * @default - no extra jar files\n   */\n  readonly extraJars?: Code[];\n\n  /**\n   * Setting this value to true prioritizes the customer's extra JAR files in the classpath.\n   *\n   * @default false - priority is not given to user-provided jars\n   *\n   * @see `--user-jars-first` in https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  readonly extraJarsFirst?: boolean;\n\n  /**\n   * Specifies whether job run queuing is enabled for the job runs for this job.\n   * A value of true means job run queuing is enabled for the job runs.\n   * If false or not populated, the job runs will not be considered for queueing.\n   * If this field does not match the value set in the job run, then the value from\n   * the job run field will be used. This property must be set to false for flex jobs.\n   * If this property is enabled, maxRetries must be set to zero.\n   *\n   * @default false\n   */\n  readonly jobRunQueuingEnabled?: boolean;\n}\n\n/**\n * PySpark ETL Jobs class\n *\n * ETL jobs support pySpark and Scala languages, for which there are separate\n * but similar constructors. ETL jobs default to the G1 worker type, but you\n * can override this default with other supported worker type values\n * (G1, G2, G4 and G8). ETL jobs defaults to Glue version 4.0, which you can\n * override to 3.0. The following ETL features are enabled by default:\n * --enable-metrics, --enable-continuous-cloudwatch-log. The Spark UI\n * (--enable-spark-ui) is off by default; enable it by setting the `sparkUI` prop.\n * You can find more details about version, worker type and other features\n * in Glue's public documentation.\n */\n@propertyInjectable\nexport class PySparkEtlJob extends SparkJob {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-glue-alpha.PySparkEtlJob';\n  private resource: CfnJob;\n\n  /**\n   * PySparkEtlJob constructor\n   */\n  constructor(scope: Construct, id: string, props: PySparkEtlJobProps) {\n    super(scope, id, props);\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    // Register the construct-managed arguments, then merge in the user's escape-hatch arguments.\n    this.executableArguments(props);\n    this.nonExecutableCommonArguments(props);\n    const defaultArguments = this.mergeDefaultArguments(props.defaultArguments);\n\n    if (props.jobRunQueuingEnabled === true && props.maxRetries !== undefined && props.maxRetries > 0) {\n      Annotations.of(this).addWarningV2(lit`GlueMaxRetriesQueuingEnabled`,\n        `maxRetries was set to ${props.maxRetries}. Overriding it to 0 with since job run queuing is enabled (service constraint)`);\n    }\n\n    this.resource = new CfnJob(this, 'Resource', {\n      name: props.jobName,\n      description: props.description,\n      role: this.role.roleArn,\n      command: {\n        name: JobType.ETL,\n        scriptLocation: this.codeS3ObjectUrl(props.script),\n        pythonVersion: PythonVersion.THREE,\n      },\n      glueVersion: props.glueVersion ?? GlueVersion.V4_0,\n      workerType: props.workerConfiguration?.workerType ?? WorkerType.G_1X,\n      numberOfWorkers: props.workerConfiguration?.numberOfWorkers ?? 10,\n      maxRetries: props.jobRunQueuingEnabled ? 0 : props.maxRetries,\n      jobRunQueuingEnabled: props.jobRunQueuingEnabled ? props.jobRunQueuingEnabled : false,\n      notificationProperty: props.notifyDelayAfter ? { notifyDelayAfter: props.notifyDelayAfter.toMinutes() } : undefined,\n      executionProperty: props.maxConcurrentRuns ? { maxConcurrentRuns: props.maxConcurrentRuns } : undefined,\n      timeout: props.timeout?.toMinutes(),\n      connections: props.connections ? { connections: props.connections.map((connection) => connection.connectionName) } : undefined,\n      securityConfiguration: props.securityConfiguration?.securityConfigurationName,\n      tags: props.tags,\n      defaultArguments,\n    });\n  }\n\n  @memoizedGetter\n  public get jobArn(): string {\n    return this.buildJobArn(this, this.jobName);\n  }\n\n  @memoizedGetter\n  public get jobName(): string {\n    return this.getResourceNameAttribute(this.resource.ref);\n  }\n\n  /**\n   * Register the executable arguments with best practices enabled by default.\n   */\n  private executableArguments(props: PySparkEtlJobProps): void {\n    this.setManagedArgument('--job-language', JobLanguage.PYTHON);\n    this.setupExtraCodeArguments(props);\n  }\n}\n"]}