regular update to Lambda github docs

Author: spaethp

doc_source/API_AliasRoutingConfiguration.md

@@ -1,6 +1,6 @@
 # AliasRoutingConfiguration<a name="API_AliasRoutingConfiguration"></a>
 
-The parent object that implements what percentage of traffic will invoke each function version\. For more information, see [Traffic Shifting Using Aliases](lambda-traffic-shifting-using-aliases.md)\. The maximum number of stream records that can be sent to your Lambda function for a single invocation\. ng\-using\-aliases"/>\.
+The parent object that implements what percentage of traffic will invoke each function version\. For more information, see [Traffic Shifting Using Aliases](lambda-traffic-shifting-using-aliases.md)\. The maximum number of stream records that can be sent to your Lambda function for a single invocation\. 
 
 ## Contents<a name="API_AliasRoutingConfiguration_Contents"></a>
 

doc_source/API_CreateEventSourceMapping.md

@@ -39,7 +39,7 @@ The request does not use any URI parameters\.
 The request accepts the following data in JSON format\.
 
  ** [BatchSize](#API_CreateEventSourceMapping_RequestSyntax) **   <a name="SSS-CreateEventSourceMapping-request-BatchSize"></a>
-The largest number of records that AWS Lambda will retrieve from your event source at the time of invoking your function\. Your function receives an event with all the retrieved records\. The default for Amazon Kinesis and Amazon DynamoDB is 100 records\.  
+The largest number of records that AWS Lambda will retrieve from your event source at the time of invoking your function\. Your function receives an event with all the retrieved records\. The default for Amazon Kinesis and Amazon DynamoDB is 100 records\. Both the default and maximum for Amazon SQS are 10 messages\.  
 Type: Integer  
 Valid Range: Minimum value of 1\. Maximum value of 10000\.  
 Required: No

doc_source/API_UpdateEventSourceMapping.md

@@ -33,7 +33,7 @@ The event source mapping identifier\.
 The request accepts the following data in JSON format\.
 
  ** [BatchSize](#API_UpdateEventSourceMapping_RequestSyntax) **   <a name="SSS-UpdateEventSourceMapping-request-BatchSize"></a>
-The maximum number of stream records that can be sent to your Lambda function for a single invocation\. If you are using an SQS queue as an event source, the maximum value is 10\.  
+The largest number of records that AWS Lambda will retrieve from your event source at the time of invoking your function\. Your function receives an event with all the retrieved records\.  
 Type: Integer  
 Valid Range: Minimum value of 1\. Maximum value of 10000\.  
 Required: No

doc_source/create-deployment-pkg-zip-java.md

@@ -55,7 +55,7 @@ After you build the project, the resulting \.zip file \(that is, your deployment
        from compileJava
        from processResources              
        into('lib') {
-           from configurations.compile.Classpath
+           from configurations.compileClasspath
        }           
    }
    
@@ -118,7 +118,7 @@ task buildZip(type: Zip) {
     from compileJava
     from processResources              
     into('lib') {
-        from configurations.compile.Classpath
+        from configurations.compileClasspath
     }           
 }
 

doc_source/go-programming-model-handler-types.md

@@ -52,14 +52,14 @@ import (
         "fmt"
         "github.com/aws/aws-lambda-go/lambda"
 )
- 
+ ``
 type MyEvent struct {
-        Name string 'json:"What is your name?"'
-        Age int     'json:"How old are you?"'
+        Name string `json:"What is your name?"`
+        Age int     `json:"How old are you?"`
 }
  
 type MyResponse struct {
-        Message string 'json:"Answer:"'
+        Message string `json:"Answer:"`
 }
  
 func HandleLambdaEvent(event MyEvent) (MyResponse, error) {
@@ -137,10 +137,10 @@ func init() {
         myObjects = result.Contents
 }
  
-func LambdaHandler() int {
+func LambdaHandler() (int, error) {
         invokeCount = invokeCount + 1
         log.Print(myObjects)
-        return invokeCount
+        return invokeCount, nil
 }
  
 func main() {

doc_source/limits.md

@@ -59,7 +59,7 @@ AWS Lambda will dynamically scale capacity in response to increased traffic, sub
 | South America \(São Paulo\) | 500 | 
 
 **Note**  
-If the default **Immediate Concurrency Increase** value is not sufficient to accommodate the traffic surge, AWS Lambda will continue to increase the number of concurrent function executions by **500 per minute** until your account safety limit has been reached or the number of concurrently executing functions is sufficient to successfully process the increased load\. Some event sources, such as Amazon Simple Queue Service, DynamoDB or Amazon Kinesis may have their own scaling limitations\. For more information, see [Understanding Scaling Behavior](scaling.md)\.
+If the default **Immediate Concurrency Increase** value is not sufficient to accommodate the traffic surge, AWS Lambda will continue to increase the number of concurrent function executions by **500 per minute** until your account safety limit has been reached or the number of concurrently executing functions is sufficient to successfully process the increased load\. For more information, see [Understanding Scaling Behavior](scaling.md)\.
 
 **To request a limit increase for concurrent executions:**
 

doc_source/nodejs-prog-model-handler.md

@@ -3,20 +3,24 @@
 AWS Lambda invokes your Lambda function via a `handler` object\. A `handler` represents the name of your Lambda function \(and serves as the entry point that AWS Lambda uses to execute your function code\. For example: 
 
 ```
-exports.myHandler = function(event, context) {
-   ...
+exports.myHandler = function(event, context, callback) {   
+    ... function code   
+    callback(null, "some success message");
+   // or 
+   // callback("some error type"); 
 }
 ```
 + `myHandler` – This is the name of the function AWS Lambda invokes\. Suppose you save this code as `helloworld.js`\. Then, `myHandler` is the function that contains your Lambda function code and `helloworld` is the name of the file that represents your deployment package\. For more information, see [Creating a Deployment Package \(Node\.js\)](nodejs-create-deployment-pkg.md)\.
 
   AWS Lambda supports two invocation types:
-  + **RequestResponse**, or `synchronous execution`: AWS Lambda returns the result of the function call to the client invoking the Lambda function\. If the handler code of your Lambda function does not specify a return value, AWS Lambda will automatically return `null` for that value\.
+  + **RequestResponse**, or *synchronous execution*: AWS Lambda returns the result of the function call to the client invoking the Lambda function\. If the handler code of your Lambda function does not specify a return value, AWS Lambda will automatically return `null` for that value\. For a simple sample, see [Example](#nodejs-prog-model-handler-example)\.
   + **Event**, or *asynchronous execution*: AWS Lambda will discard any results of the function call\. 
 **Note**  
 If you discover that your Lambda function does not process the event using asynchronous invocation, you can investigate the failure using [Dead Letter Queues](dlq.md)\.
 
-     Event sources can range from a supported AWS service or custom applications that invoke your Lambda function\. For examples, see [Sample Events Published by Event Sources](eventsources.md) 
+     Event sources can range from a supported AWS service or custom applications that invoke your Lambda function\. For examples, see [Sample Events Published by Event Sources](eventsources.md)\. For a simple sample, see [Example](#nodejs-prog-model-handler-example)\. 
 + `context` – AWS Lambda uses this parameter to provide details of your Lambda function's execution\. For more information, see [The Context Object \(Node\.js\)](nodejs-prog-model-context.md)\.
++ `callback` \(optional\)– See [Using the Callback Parameter](#nodejs-prog-model-handler-callback)\.
 
 ## Using the Callback Parameter<a name="nodejs-prog-model-handler-callback"></a>
 

doc_source/scaling.md

@@ -1,33 +1,29 @@
 # Understanding Scaling Behavior<a name="scaling"></a>
 
-Concurrent executions refers to the number of executions of your function code that are happening at any given time\. You can estimate the concurrent execution count, but the concurrent execution count will differ depending on whether or not your Lambda function is processing events from a stream\-based event source\. 
+Concurrent executions refers to the number of executions of your function code that are happening at any given time\. You can estimate the concurrent execution count, but the concurrent execution count will differ depending on whether or not your Lambda function is processing events from a poll\-based event source\.  If you create a Lambda function to process events from event sources that aren't poll\-based \(for example, Lambda can process every event from other sources, like Amazon S3 or API Gateway\), each published event is a unit of work, in parallel, up to your account limits\. Therefore, the number of events \(or requests\) these event sources publish influences the concurrency\. You can use the this formula to estimate your concurrent Lambda function invocations: 
+
+```
+events (or requests) per second * function duration
+```
+
+ For example, consider a Lambda function that processes Amazon S3 events\. Suppose that the Lambda function takes on average three seconds and Amazon S3 publishes 10 events per second\. Then, you will have 30 concurrent executions of your Lambda function\. 
+
+The number of concurrent executions for poll\-based event sources also depends on additional factors, as noted following:
 + **Poll\-based event sources that are stream\-based**
   + Amazon Kinesis Data Streams
   + Amazon DynamoDB
 
   For Lambda functions that process Kinesis or DynamoDB streams the number of shards is the unit of concurrency\. If your stream has 100 active shards, there will be at most 100 Lambda function invocations running concurrently\. This is because Lambda processes each shard’s events in sequence\. **Poll\-based event sources that are not stream\-based**: For Lambda functions that process Amazon SQS queues, AWS Lambda will automatically scale the polling on the queue until the maximum concurrency level is reached, where each message batch can be considered a single concurrent unit\. AWS Lambda's automatic scaling behavior is designed to keep polling costs low when a queue is empty while simultaneously enabling you to achieve high throughput when the queue is being used heavily\. 
 
-  Here is how it works:
-  + When an Amazon SQS event source mapping is initially enabled, Lambda begins long\-polling the Amazon SQS queue\. Long polling helps reduce the cost of polling Amazon Simple Queue Service by reducing the number of empty responses, while proving optimal processing latency when messages arrive\. As the influx of messages to a queue increases, AWS Lambda automatically scales up polling activity until the number of concurrent function executions reaches 1000, the account concurrency limit, or the \(optional\) function concurrency limit, whichever is lower\. SQS Event Sources support an initial burst of 5 concurrent function invocations and increase concurrency by 60 concurrent invocations per minute\.
-  + Lambda monitors the number of [inflight messages](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html#inflight-messages), and when it detects that this number is increasing, it will increase the polling frequency by 20 [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html) requests per minute and the function concurrency by 60 calls per minute\. As long as the queue remains busy, scale up continues until at least one of the following occurs:
-    + Polling frequency reaches 100 simultaneous ReceiveMessage requests and function invocation concurrency reaches 1,000\.
-    + The account concurrency maximum has been reached\.
-    + The per\-function concurrency limit of the function attached to the SQS queue \(if any\) has been reached\.
+  When an Amazon SQS event source mapping is initially enabled, Lambda begins long\-polling the Amazon SQS queue\. Long polling helps reduce the cost of polling Amazon Simple Queue Service by reducing the number of empty responses, while providing optimal processing latency when messages arrive\.
 
-  When AWS Lambda detects that the number of inflight messages is decreasing, it will decrease the polling frequency by 10 ReceiveMessage requests per minute and decrease the concurrency used to invoke your function by 30 calls per minute\. 
+  As the influx of messages to a queue increases, AWS Lambda automatically scales up polling activity until the number of concurrent function executions reaches 1000, the account concurrency limit, or the \(optional\) function concurrency limit, whichever is lower\. Amazon Simple Queue Service supports an initial burst of 5 concurrent function invocations and increases concurrency by 60 concurrent invocations per minute\.
 **Note**  
 [Account\-level limits](http://docs.aws.amazon.com/lambda/latest/dg/limits.html) are impacted by other functions in the account, and per\-function concurrency applies to all events sent to a function\. For more information, see [Managing Concurrency](concurrent-executions.md)\.
-+ **Event sources that aren't stream\-based** – If you create a Lambda function to process events from event sources that aren't stream\-based \(for example, Lambda can process every event from other sources, like Amazon S3 or API Gateway\), each published event is a unit of work, in parallel, up to your account limits\. Therefore, the number of events \(or requests\) these event sources publish influences the concurrency\. You can use the this formula to estimate your concurrent Lambda function invocations:
-
-  ```
-  events (or requests) per second * function duration
-  ```
-
-  For example, consider a Lambda function that processes Amazon S3 events\. Suppose that the Lambda function takes on average three seconds and Amazon S3 publishes 10 events per second\. Then, you will have 30 concurrent executions of your Lambda function\.
 
 ## Request Rate<a name="concurrent-executions-request-rate"></a>
 
-Request rate refers to the rate at which your Lambda function is invoked\. For all services except the stream\-based services, the request rate is the rate at which the event sources generate the events\. For stream\-based services, AWS Lambda calculates the request rate as follow:
+Request rate refers to the rate at which your Lambda function is invoked\. For all services except the stream\-based services, the request rate is the rate at which the event sources generate the events\. For stream\-based services, AWS Lambda calculates the request rate as follows:
 
 ```
 request rate = number of concurrent executions / function duration

doc_source/with-sqs.md

@@ -24,7 +24,7 @@ Note the following about how Amazon Simple Queue Service and AWS Lambda integrat
 + [UpdateEventSourceMapping](API_UpdateEventSourceMapping.md)
 
 When using these operations to map your Lambda function to an Amazon SQS queue, note the following configuration parameters:
-+ **BatchSize**: The largest number of records that AWS Lambda will retrieve from each [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html) call\. The maximum batch size supported by Amazon Simple Queue Service is up to 10 queue messages per batch\.
++ **BatchSize**: The number of records that AWS Lambda will retrieve from each [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html) call\. Both the default and maximum batch size supported by Amazon Simple Queue Service is up to 10 queue messages per batch\.
 + **Enabled**: A flag to signal AWS Lambda that it should start polling your specified Amazon SQS queue\. 
 + **EventSourceArn**: The ARN \(Amazon Resource Name\) of your Amazon SQS queue that AWS Lambda is monitoring for new messages\. 
 + **FunctionName**: The Lambda function to invoke when AWS Lambda detects new messages on your configured Amazon SQS queue\.