@aws-cdk/aws-glue-alpha 2.176.0-alpha.0 → 2.178.0-alpha.0

package/lib/jobs/job.js

@@ -0,0 +1,298 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Job = exports.JobBase = void 0;
+const jsiiDeprecationWarnings = require("../../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cloudwatch = require("aws-cdk-lib/aws-cloudwatch");
+const events = require("aws-cdk-lib/aws-events");
+const iam = require("aws-cdk-lib/aws-iam");
+const cdk = require("aws-cdk-lib/core");
+const constants_1 = require("../constants");
+/**
+ * A base class is needed to be able to import existing Jobs into a CDK app to
+ * reference as part of a larger stack or construct. JobBase has the subset
+ * of attribtues required to idenitfy and reference an existing Glue Job,
+ * as well as some CloudWatch metric conveneince functions to configure an
+ * event-driven flow using the job.
+ */
+class JobBase extends cdk.Resource {
+    /**
+     * Create a CloudWatch Event Rule for this Glue Job when it's in a given state
+     *
+     * @param id construct id
+     * @param options event options. Note that some values are overridden if provided, these are
+     *  - eventPattern.source = ['aws.glue']
+     *  - eventPattern.detailType = ['Glue Job State Change', 'Glue Job Run Status']
+     *  - eventPattern.detail.jobName = [this.jobName]
+     *
+     * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types
+     */
+    onEvent(id, options = {}) {
+        const rule = new events.Rule(this, id, options);
+        rule.addTarget(options.target);
+        rule.addEventPattern({
+            source: ['aws.glue'],
+            detailType: ['Glue Job State Change', 'Glue Job Run Status'],
+            detail: {
+                jobName: [this.jobName],
+            },
+        });
+        return rule;
+    }
+    /**
+     * Create a CloudWatch Event Rule for the transition into the input jobState.
+     *
+     * @param id construct id.
+     * @param jobState the job state.
+     * @param options optional event options.
+     */
+    onStateChange(id, jobState, options = {}) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_JobState(jobState);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.onStateChange);
+            }
+            throw error;
+        }
+        const rule = this.onEvent(id, {
+            description: `Rule triggered when Glue job ${this.jobName} is in ${jobState} state`,
+            ...options,
+        });
+        rule.addEventPattern({
+            detail: {
+                state: [jobState],
+            },
+        });
+        return rule;
+    }
+    /**
+     * Create a CloudWatch Event Rule matching JobState.SUCCEEDED.
+     *
+     * @param id construct id.
+     * @param options optional event options. default is {}.
+     */
+    onSuccess(id, options = {}) {
+        return this.onStateChange(id, constants_1.JobState.SUCCEEDED, options);
+    }
+    /**
+     * Return a CloudWatch Event Rule matching FAILED state.
+     *
+     * @param id construct id.
+     * @param options optional event options. default is {}.
+     */
+    onFailure(id, options = {}) {
+        return this.onStateChange(id, constants_1.JobState.FAILED, options);
+    }
+    /**
+     * Return a CloudWatch Event Rule matching TIMEOUT state.
+     *
+     * @param id construct id.
+     * @param options optional event options. default is {}.
+     */
+    onTimeout(id, options = {}) {
+        return this.onStateChange(id, constants_1.JobState.TIMEOUT, options);
+    }
+    /**
+     * Create a CloudWatch metric.
+     *
+     * @param metricName name of the metric typically prefixed with `glue.driver.`, `glue.<executorId>.` or `glue.ALL.`.
+     * @param type the metric type.
+     * @param props metric options.
+     *
+     * @see https://docs.aws.amazon.com/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html
+     */
+    metric(metricName, type, props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_MetricType(type);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.metric);
+            }
+            throw error;
+        }
+        return new cloudwatch.Metric({
+            metricName,
+            namespace: 'Glue',
+            dimensionsMap: {
+                JobName: this.jobName,
+                JobRunId: 'ALL',
+                Type: type,
+            },
+            ...props,
+        }).attachTo(this);
+    }
+    /**
+     * Return a CloudWatch Metric indicating job success.
+     *
+     * This metric is based on the Rule returned by no-args onSuccess() call.
+     */
+    metricSuccess(props) {
+        return metricRule(this.metricJobStateRule('SuccessMetricRule', constants_1.JobState.SUCCEEDED), props);
+    }
+    /**
+     * Return a CloudWatch Metric indicating job failure.
+     *
+     * This metric is based on the Rule returned by no-args onFailure() call.
+     */
+    metricFailure(props) {
+        return metricRule(this.metricJobStateRule('FailureMetricRule', constants_1.JobState.FAILED), props);
+    }
+    /**
+     * Return a CloudWatch Metric indicating job timeout.
+     *
+     * This metric is based on the Rule returned by no-args onTimeout() call.
+     */
+    metricTimeout(props) {
+        return metricRule(this.metricJobStateRule('TimeoutMetricRule', constants_1.JobState.TIMEOUT), props);
+    }
+    /**
+     * Creates or retrieves a singleton event rule for the input job state for use with the metric JobState methods.
+     *
+     * @param id construct id.
+     * @param jobState the job state.
+     */
+    metricJobStateRule(id, jobState) {
+        return this.node.tryFindChild(id) ?? this.onStateChange(id, jobState);
+    }
+    /**
+     * Returns the job arn
+     */
+    buildJobArn(scope, jobName) {
+        return cdk.Stack.of(scope).formatArn({
+            service: 'glue',
+            resource: 'job',
+            resourceName: jobName,
+        });
+    }
+}
+exports.JobBase = JobBase;
+_a = JSII_RTTI_SYMBOL_1;
+JobBase[_a] = { fqn: "@aws-cdk/aws-glue-alpha.JobBase", version: "2.178.0-alpha.0" };
+/**
+ * A Glue Job.
+ * @resource AWS::Glue::Job
+ */
+class Job extends JobBase {
+    /**
+     * Identifies an existing Glue Job from a subset of attributes that can
+     * be referenced from within another Stack or Construct.
+     *
+     * @param scope The scope creating construct (usually `this`)
+     * @param id The construct's id.
+     * @param attrs Attributes for the Glue Job we want to import
+     */
+    static fromJobAttributes(scope, id, attrs) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_JobImportAttributes(attrs);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.fromJobAttributes);
+            }
+            throw error;
+        }
+        class Import extends JobBase {
+            constructor() {
+                super(...arguments);
+                this.jobName = attrs.jobName;
+                this.jobArn = this.buildJobArn(scope, attrs.jobName);
+                this.grantPrincipal = attrs.role ?? new iam.UnknownPrincipal({ resource: this });
+            }
+        }
+        return new Import(scope, id);
+    }
+    /**
+     * Check no usage of reserved arguments.
+     *
+     * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    checkNoReservedArgs(defaultArguments) {
+        if (defaultArguments) {
+            const reservedArgs = new Set(['--debug', '--mode', '--JOB_NAME']);
+            Object.keys(defaultArguments).forEach((arg) => {
+                if (reservedArgs.has(arg)) {
+                    throw new Error(`The ${arg} argument is reserved by Glue. Don't set it`);
+                }
+            });
+        }
+        return defaultArguments;
+    }
+    /**
+     * Setup Continuous Loggiung Properties
+     * @param role The IAM role to use for continuous logging
+     * @param props The properties for continuous logging configuration
+     * @returns String containing the args for the continuous logging command
+     */
+    setupContinuousLogging(role, props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_ContinuousLoggingProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.setupContinuousLogging);
+            }
+            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;
+        }
+        return args;
+    }
+    codeS3ObjectUrl(code) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_Code(code);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.codeS3ObjectUrl);
+            }
+            throw error;
+        }
+        const s3Location = code.bind(this, this.role).s3Location;
+        return `s3://${s3Location.bucketName}/${s3Location.objectKey}`;
+    }
+}
+exports.Job = Job;
+_b = JSII_RTTI_SYMBOL_1;
+Job[_b] = { fqn: "@aws-cdk/aws-glue-alpha.Job", version: "2.178.0-alpha.0" };
+/**
+ * Create a CloudWatch Metric that's based on Glue Job events
+ * {@see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types}
+ * The metric has namespace = 'AWS/Events', metricName = 'TriggeredRules' and RuleName = rule.ruleName dimension.
+ *
+ * @param rule for use in setting RuleName dimension value
+ * @param props metric properties
+ */
+function metricRule(rule, props) {
+    return new cloudwatch.Metric({
+        namespace: 'AWS/Events',
+        metricName: 'TriggeredRules',
+        dimensionsMap: { RuleName: rule.ruleName },
+        statistic: cloudwatch.Statistic.SUM,
+        ...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 * as logs from 'aws-cdk-lib/aws-logs';\nimport * as cdk from 'aws-cdk-lib/core';\nimport * as constructs from 'constructs';\nimport { Code } from '..';\nimport { MetricType, JobState, WorkerType, GlueVersion } from '../constants';\nimport { IConnection } from '../connection';\nimport { 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 continouous 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 attribtues required to idenitfy and reference an existing Glue Job,\n * as well as some CloudWatch metric conveneince 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 ionly used when using fromJobAttributes\n * to identify and reference the existing job.\n */\nexport interface JobImportAttributes {\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 * JobProperties will be used to create new Glue Jobs using this L2 Construct.\n */\nexport interface JobProperties {\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   * Number of Workers (optional)\n   * Number of workers for Glue to use during job execution\n   *\n   * @default 10\n   */\n  readonly numberOfWorkers?: number;\n\n  /**\n   * Worker Type (optional)\n   * Type of Worker for Glue to use during job execution\n   * Enum options: Standard, G_1X, G_2X, G_025X. G_4X, G_8X, Z_2X\n   *\n   * @default WorkerType.G_1X\n   */\n  readonly workerType?: WorkerType;\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   * @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 3.0 for ETL\n   */\n  readonly glueVersion?: GlueVersion;\n\n  /**\n   * Enables the collection of metrics for job profiling.\n   *\n   * @default - no profiling metrics emitted.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  readonly enableProfilingMetrics? :boolean;\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: JobImportAttributes): 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 Error(`The ${arg} argument is reserved by Glue. Don't set it`);\n        }\n      });\n    }\n    return defaultArguments;\n  }\n\n  /**\n   * Setup Continuous Loggiung 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  public 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.Statistic.SUM,\n    ...props,\n  }).attachTo(rule);\n}\n\n"]}

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

@@ -0,0 +1,81 @@
+import * as iam from 'aws-cdk-lib/aws-iam';
+import { Job, JobProperties } from './job';
+import { Construct } from 'constructs';
+import { SparkUIProps, SparkUILoggingLocation } from './spark-ui-utils';
+import { Code } from '../code';
+/**
+ * Properties for creating a Python Spark ETL job
+ */
+export interface PySparkEtlJobProps extends JobProperties {
+    /**
+     * Enables the Spark UI debugging and monitoring with the specified props.
+     *
+     * @default - Spark UI debugging and monitoring is disabled.
+     *
+     * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html
+     * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    readonly sparkUI?: SparkUIProps;
+    /**
+     * Extra Python Files S3 URL (optional)
+     * S3 URL where additional python dependencies are located
+     *
+     * @default - no extra files
+     */
+    readonly extraPythonFiles?: Code[];
+    /**
+     * Additional files, such as configuration files that AWS Glue copies to the working directory of your script before executing it.
+     *
+     * @default - no extra files specified.
+     *
+     * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    readonly extraFiles?: Code[];
+    /**
+     * Specifies whether job run queuing is enabled for the job runs for this job.
+     * A value of true means job run queuing is enabled for the job runs.
+     * If false or not populated, the job runs will not be considered for queueing.
+     * If this field does not match the value set in the job run, then the value from
+     * the job run field will be used. This property must be set to false for flex jobs.
+     * If this property is enabled, maxRetries must be set to zero.
+     *
+     * @default false
+     */
+    readonly jobRunQueuingEnabled?: boolean;
+}
+/**
+ * PySpark ETL Jobs class
+ *
+ * ETL jobs support pySpark and Scala languages, for which there are separate
+ * but similar constructors. ETL jobs default to the G2 worker type, but you
+ * can override this default with other supported worker type values
+ * (G1, G2, G4 and G8). ETL jobs defaults to Glue version 4.0, which you can
+ * override to 3.0. The following ETL features are enabled by default:
+ * —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.
+ * You can find more details about version, worker type and other features
+ * in Glue's public documentation.
+ */
+export declare class PySparkEtlJob extends Job {
+    readonly jobArn: string;
+    readonly jobName: string;
+    readonly role: iam.IRole;
+    readonly grantPrincipal: iam.IPrincipal;
+    /**
+     * The Spark UI logs location if Spark UI monitoring and debugging is enabled.
+     *
+     * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html
+     * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html
+     */
+    readonly sparkUILoggingLocation?: SparkUILoggingLocation;
+    /**
+     * PySparkEtlJob constructor
+     */
+    constructor(scope: Construct, id: string, props: PySparkEtlJobProps);
+    /**
+     * Set the executable arguments with best practices enabled by default
+     *
+     * @returns An array of arguments for Glue to use on execution
+     */
+    private executableArguments;
+    private setupSparkUI;
+}

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

@@ -0,0 +1,130 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PySparkEtlJob = void 0;
+const jsiiDeprecationWarnings = require("../../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const iam = require("aws-cdk-lib/aws-iam");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const aws_glue_1 = require("aws-cdk-lib/aws-glue");
+const job_1 = require("./job");
+const constants_1 = require("../constants");
+const spark_ui_utils_1 = require("./spark-ui-utils");
+const metadata_resource_1 = require("aws-cdk-lib/core/lib/metadata-resource");
+/**
+ * PySpark ETL Jobs class
+ *
+ * ETL jobs support pySpark and Scala languages, for which there are separate
+ * but similar constructors. ETL jobs default to the G2 worker type, but you
+ * can override this default with other supported worker type values
+ * (G1, G2, G4 and G8). ETL jobs defaults to Glue version 4.0, which you can
+ * override to 3.0. The following ETL features are enabled by default:
+ * —enable-metrics, —enable-spark-ui, —enable-continuous-cloudwatch-log.
+ * You can find more details about version, worker type and other features
+ * in Glue's public documentation.
+ */
+class PySparkEtlJob extends job_1.Job {
+    /**
+     * PySparkEtlJob constructor
+     */
+    constructor(scope, id, props) {
+        super(scope, id, {
+            physicalName: props.jobName,
+        });
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_glue_alpha_PySparkEtlJobProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, PySparkEtlJob);
+            }
+            throw error;
+        }
+        // Enhanced CDK Analytics Telemetry
+        (0, metadata_resource_1.addConstructMetadata)(this, props);
+        // Set up role and permissions for principal
+        this.role = props.role, {
+            assumedBy: new iam.ServicePrincipal('glue.amazonaws.com'),
+            managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSGlueServiceRole')],
+        };
+        this.grantPrincipal = this.role;
+        // Enable SparkUI by default as a best practice
+        const sparkUIArgs = props.sparkUI?.bucket ? this.setupSparkUI(this.role, props.sparkUI) : undefined;
+        this.sparkUILoggingLocation = sparkUIArgs?.location;
+        // Enable CloudWatch metrics and continuous logging by default as a best practice
+        const continuousLoggingArgs = this.setupContinuousLogging(this.role, props.continuousLogging);
+        const profilingMetricsArgs = { '--enable-metrics': '' };
+        const observabilityMetricsArgs = { '--enable-observability-metrics': 'true' };
+        // Gather executable arguments
+        const execuatbleArgs = this.executableArguments(props);
+        // Conbine command line arguments into a single line item
+        const defaultArguments = {
+            ...execuatbleArgs,
+            ...continuousLoggingArgs,
+            ...profilingMetricsArgs,
+            ...observabilityMetricsArgs,
+            ...sparkUIArgs?.args,
+            ...this.checkNoReservedArgs(props.defaultArguments),
+        };
+        const jobResource = new aws_glue_1.CfnJob(this, 'Resource', {
+            name: props.jobName,
+            description: props.description,
+            role: this.role.roleArn,
+            command: {
+                name: constants_1.JobType.ETL,
+                scriptLocation: this.codeS3ObjectUrl(props.script),
+                pythonVersion: constants_1.PythonVersion.THREE,
+            },
+            glueVersion: props.glueVersion ?? constants_1.GlueVersion.V4_0,
+            workerType: props.workerType ?? constants_1.WorkerType.G_1X,
+            numberOfWorkers: props.numberOfWorkers ? props.numberOfWorkers : 10,
+            maxRetries: props.jobRunQueuingEnabled ? 0 : props.maxRetries,
+            jobRunQueuingEnabled: props.jobRunQueuingEnabled ? props.jobRunQueuingEnabled : false,
+            executionProperty: props.maxConcurrentRuns ? { maxConcurrentRuns: props.maxConcurrentRuns } : undefined,
+            timeout: props.timeout?.toMinutes(),
+            connections: props.connections ? { connections: props.connections.map((connection) => connection.connectionName) } : undefined,
+            securityConfiguration: props.securityConfiguration?.securityConfigurationName,
+            tags: props.tags,
+            defaultArguments,
+        });
+        const resourceName = this.getResourceNameAttribute(jobResource.ref);
+        this.jobArn = this.buildJobArn(this, resourceName);
+        this.jobName = resourceName;
+    }
+    /**
+     * Set the executable arguments with best practices enabled by default
+     *
+     * @returns An array of arguments for Glue to use on execution
+     */
+    executableArguments(props) {
+        const args = {};
+        args['--job-language'] = constants_1.JobLanguage.PYTHON;
+        if (props.extraPythonFiles && props.extraPythonFiles.length > 0) {
+            args['--extra-py-files'] = props.extraPythonFiles.map(code => this.codeS3ObjectUrl(code)).join(',');
+        }
+        if (props.extraFiles && props.extraFiles.length > 0) {
+            args['--extra-files'] = props.extraFiles.map(code => this.codeS3ObjectUrl(code)).join(',');
+        }
+        return args;
+    }
+    setupSparkUI(role, sparkUiProps) {
+        (0, spark_ui_utils_1.validateSparkUiPrefix)(sparkUiProps.prefix);
+        const bucket = sparkUiProps.bucket ?? new aws_s3_1.Bucket(this, 'SparkUIBucket', { enforceSSL: true, encryption: aws_s3_1.BucketEncryption.S3_MANAGED });
+        bucket.grantReadWrite(role, (0, spark_ui_utils_1.cleanSparkUiPrefixForGrant)(sparkUiProps.prefix));
+        const args = {
+            '--enable-spark-ui': 'true',
+            '--spark-event-logs-path': bucket.s3UrlForObject(sparkUiProps.prefix).replace(/\/?$/, '/'), // path will always end with a slash
+        };
+        return {
+            location: {
+                prefix: sparkUiProps.prefix,
+                bucket,
+            },
+            args,
+        };
+    }
+}
+exports.PySparkEtlJob = PySparkEtlJob;
+_a = JSII_RTTI_SYMBOL_1;
+PySparkEtlJob[_a] = { fqn: "@aws-cdk/aws-glue-alpha.PySparkEtlJob", version: "2.178.0-alpha.0" };
+//# 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 * as iam from 'aws-cdk-lib/aws-iam';\nimport { Bucket, BucketEncryption } from 'aws-cdk-lib/aws-s3';\nimport { CfnJob } from 'aws-cdk-lib/aws-glue';\nimport { Job, JobProperties } from './job';\nimport { Construct } from 'constructs';\nimport { JobType, GlueVersion, JobLanguage, PythonVersion, WorkerType } from '../constants';\nimport { SparkUIProps, SparkUILoggingLocation, validateSparkUiPrefix, cleanSparkUiPrefixForGrant } from './spark-ui-utils';\nimport { Code } from '../code';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\n\n/**\n * Properties for creating a Python Spark ETL job\n */\nexport interface PySparkEtlJobProps extends JobProperties {\n  /**\n   * Enables the Spark UI debugging and monitoring with the specified props.\n   *\n   * @default - Spark UI debugging and monitoring is disabled.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  readonly sparkUI?: SparkUIProps;\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   * 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 G2 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-spark-ui, —enable-continuous-cloudwatch-log.\n * You can find more details about version, worker type and other features\n * in Glue's public documentation.\n */\nexport class PySparkEtlJob extends Job {\n  public readonly jobArn: string;\n  public readonly jobName: string;\n  public readonly role: iam.IRole;\n  public readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * The Spark UI logs location if Spark UI monitoring and debugging is enabled.\n   *\n   * @see https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html\n   * @see https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html\n   */\n  public readonly sparkUILoggingLocation?: SparkUILoggingLocation;\n\n  /**\n   * PySparkEtlJob constructor\n   */\n  constructor(scope: Construct, id: string, props: PySparkEtlJobProps) {\n    super(scope, id, {\n      physicalName: props.jobName,\n    });\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    // Set up role and permissions for principal\n    this.role = props.role, {\n      assumedBy: new iam.ServicePrincipal('glue.amazonaws.com'),\n      managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSGlueServiceRole')],\n    };\n    this.grantPrincipal = this.role;\n\n    // Enable SparkUI by default as a best practice\n    const sparkUIArgs = props.sparkUI?.bucket ? this.setupSparkUI(this.role, props.sparkUI) : undefined;\n    this.sparkUILoggingLocation = sparkUIArgs?.location;\n\n    // Enable CloudWatch metrics and continuous logging by default as a best practice\n    const continuousLoggingArgs = this.setupContinuousLogging(this.role, props.continuousLogging);\n    const profilingMetricsArgs = { '--enable-metrics': '' };\n    const observabilityMetricsArgs = { '--enable-observability-metrics': 'true' };\n\n    // Gather executable arguments\n    const execuatbleArgs = this.executableArguments(props);\n\n    // Conbine command line arguments into a single line item\n    const defaultArguments = {\n      ...execuatbleArgs,\n      ...continuousLoggingArgs,\n      ...profilingMetricsArgs,\n      ...observabilityMetricsArgs,\n      ...sparkUIArgs?.args,\n      ...this.checkNoReservedArgs(props.defaultArguments),\n    };\n\n    const jobResource = 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.workerType ?? WorkerType.G_1X,\n      numberOfWorkers: props.numberOfWorkers ? props.numberOfWorkers : 10,\n      maxRetries: props.jobRunQueuingEnabled ? 0 : props.maxRetries,\n      jobRunQueuingEnabled: props.jobRunQueuingEnabled ? props.jobRunQueuingEnabled : false,\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    const resourceName = this.getResourceNameAttribute(jobResource.ref);\n    this.jobArn = this.buildJobArn(this, resourceName);\n    this.jobName = resourceName;\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\n    if (props.extraPythonFiles && props.extraPythonFiles.length > 0) {\n      args['--extra-py-files'] = props.extraPythonFiles.map(code => this.codeS3ObjectUrl(code)).join(',');\n    }\n    if (props.extraFiles && props.extraFiles.length > 0) {\n      args['--extra-files'] = props.extraFiles.map(code => this.codeS3ObjectUrl(code)).join(',');\n    }\n\n    return args;\n  }\n\n  private setupSparkUI(role: iam.IRole, sparkUiProps: SparkUIProps) {\n    validateSparkUiPrefix(sparkUiProps.prefix);\n    const bucket = sparkUiProps.bucket ?? new Bucket(this, 'SparkUIBucket', { enforceSSL: true, encryption: BucketEncryption.S3_MANAGED });\n    bucket.grantReadWrite(role, cleanSparkUiPrefixForGrant(sparkUiProps.prefix));\n    const args = {\n      '--enable-spark-ui': 'true',\n      '--spark-event-logs-path': bucket.s3UrlForObject(sparkUiProps.prefix).replace(/\\/?$/, '/'), // path will always end with a slash\n    };\n\n    return {\n      location: {\n        prefix: sparkUiProps.prefix,\n        bucket,\n      },\n      args,\n    };\n  }\n}\n"]}