Google App Engine SDK Changelog

What's new in Google App Engine SDK 1.9.25

Jan 14, 2016
  • Added PyAMF version 0.7.2 (Beta).
  • Development server no longer supports the "php" runtime. This will result in a Runtime Error. Please use "php55" instead.
  • Admin Console menus start redirecting to Developers Console. Select services such as the Admin Logs will continue to be available in the Admin Console
  • Datastore now allows properties to represent the empty list.
  • Failed tasks in queues configured with a ‘retry_limit’ of zero will no longer be retried.

New in Google App Engine SDK 1.9.20 (May 6, 2015)

  • All:
  • OAuth2 is now the default authentication method is appcfg. It is still possible to use password-based authentication by specifying --no_oauth2 but this option will be removed in the next release.
  • PHP:
  • User can now use the "#default#" keyword to represent the app's default bucket when specifying a GCS path, e.g. gs://#default#/folder/test.txt.
  • Enabled the php://output stream.
  • Disabled uploading of PHP 5.4 applications. Applications are now expected to be using the PHP 5.5 runtime.

New in Google App Engine SDK 1.9.19 (May 6, 2015)

  • All:
  • appcfg now outputs a warning if OAuth2 is not used for authentication when deploying or managing an application. OAuth2 will become the default in the 1.9.20 release.
  • Many Admin Console pages now redirect to the Developer Console. Users may still choose to return to the Admin Console.
  • App creation feature is now disabled on the Admin Console. Users will need to create Cloud Projects in the Developer Console.
  • Removed Memcache top keys report by ops rate. Users still have access to Memcache top keys report by MCU (Memcache unit)
  • Increased Datastore indexed string and blob length limits to 1500 bytes
  • Managed VMs:
  • Added ability to specify the GCE network in which to create managed VMs. If unspecified, the 'default' network is used.
  • Python:
  • Fixed a bug in Dev App server that prevented Google Cloud Endpoints APIs from accepting gzipped responses in local testing.
  • Updated Openssl to v1.0.1l
  • PHP:
  • Updated Openssl to v1.0.1l
  • The following headers can be set when writing objects to Google Cloud Storage: 'Cache-Control', 'Content-Disposition', 'Content-Encoding', 'Content-Language', and 'Content-Type'
  • Fixed misleading filesystem errors due to the read-only production filesystem
  • Enabled stat cache for Google Cloud Storage
  • Removed the glob:// stream wrapper
  • Java:
  • Fixed an bug in the Java SDK where LogQuery throws an exception when more than 20 log entries are queried.
  • Added a Files API deprecation warning to the Java DevAppServer.
  • Allow applications to use the class javax.xml.crypto.dom.DOMURIReference.
  • Go:
  • This release is based on Go 1.4.2.

New in Google App Engine SDK 1.9.18 (Feb 20, 2015)

  • All:
  • Newly created apps will have modules enabled by default. Existing apps will still be able to use the existing "migrate my app to modules" workflow.
  • Datastore cross-group transactions now allow 25 entity groups (up from 5).
  • Users will have the option to use traffic migration instead of set default version.
  • Faceted Search is now in Beta.
  • VM Engines users can now specify the size of disk needed; there's no limitation that sizes be less than 10 GB.
  • Mac Launcher now uses OAuth2 exclusively for app deployments. Permissions are granted through the browser instead of a login dialog.
  • Python:
  • Added a new version of the third-party library MySQLdb (version 1.24). To use it, update app.yaml and redeploy.
  • Fixed a bug in Python 2.7 logging that sometimes impacted logs when flushed.
  • PHP:
  • PHP 5.5 runtime (php55) is now available. It runs alongside the existing PHP 5.4 runtime (php). To use it, opt into the new runtime in the app.yaml file.
  • Added ImageMagick extension (php55 only). Users will have to enable this explicitly by specifying "extension=imagick.so" in their php.ini file.
  • Added in-memory tempnam() support. This feature is only available in the PHP 5.5 runtime. tempnam() will return a path to in-memory virtual files based on VFS stream wrapper.
  • Fixed glob() support for PHP.
  • Added MongoDB as a standard PHP library (php55 only)
  • Enabled the exif extension.
  • Enabled the mailparse extension
  • Enabled the cURL extension (php55 only)
  • Provided a cURL implementation using the standard HTTP streams API for apps that do not need the complete cURL extension.
  • Enabled the xslt extension
  • Added support for XDebug on the Windows and Mac SDK
  • Fixed the issue of Browsecap file not loading.
  • Fixed the issue of incoming email limit not being able to be configured
  • Fixed the issue of DNS related functions not enabled in runtime
  • Fixed the issue of errors resulting from uploading multiple files using a name array
  • Fixed the issue that loaded extensions not indicating that memcache was available in the dev appserver
  • Upgraded PHP 5.4 from PHP 5.4.32 to PHP 5.4.35
  • Fixed the issue of allow_url_include = "1" being required on dev server
  • Fixed the issue of input truncation when reading binary POST data.
  • Fixed the issue of PHP Message e-mailer forcing only raw e-mail addresses for sender/reply-to

New in Google App Engine SDK 1.9.17 (Dec 11, 2014)

  • Managed VMs:
  • Managed VMs are now available as an open Beta feature of App Engine.
  • User-defined health checks on App Engine Managed VMs no longer require an 'ok' message body; any status 200 response is considered healthy.
  • Python:
  • The old development appserver (old_dev_appserver.py) has been removed from the SDK. However, old SDKs that contain old_dev_appserver.py will continue to be available.
  • PHP:
  • Fixed the issue which prevented the ability to fseek a GCS file beyond 524287 (=0x7FFFF).
  • https://code.google.com/p/googleappengine/issues/detail?id=10881
  • Fixed the issue causing a value of "valid metadata with spaces" to fail validation.

New in Google App Engine SDK 1.9.15 (Nov 5, 2014)

  • All:
  • Fixed an issue with Datastore stats not displaying entity counts.
  • Python:
  • search.GetResponse in the Search API now supports __len__.
  • The get_access_token() method of the App Identity API now caches access tokens within the instance.
  • Fixed an issue with Cloud Endpoints where multi-class Python APIs that reused method names could result in incorrect API descriptors.
  • PHP:
  • Temporary uploaded files are now unlinked (deleted) if not moved. Empty files not written to a temporary directory are removed.
  • Fixed an issue with get_define_constraints not returning a Core array.

New in Google App Engine SDK 1.9.14 (Oct 23, 2014)

  • All:
  • The URL Fetch service will always issue a GET request when it receives and responds to a 302 response; previously it would preserve the original HTTP method. This new behavior is in line with modern conventions. You can use the final_url field of the Response object (or a similar object in other APIs) to determine if your fetches are being redirected.

New in Google App Engine SDK 1.9.12 (Oct 10, 2014)

  • Python:
  • The libxslt library has been updated from v1.1.22 to v1.1.28
  • Fixed an issue with NDB where a user gets an error stating "AugmentedQuery' object has no attribute 'filter_predicate'" when running a query without a filter predicate.
  • PHP:
  • Fixed an issue where users are unable to read newly created files in Google Cloud Storage.

New in Google App Engine SDK 1.9.11 (Sep 12, 2014)

  • Python:
  • Fixed an issue with the Search API not returning results in the proper date order.
  • PHP:
  • PHP has now been updated to 5.4.32.

New in Google App Engine SDK 1.9.10 (Aug 29, 2014)

  • Python:
  • Asynchronous calls are now supported in the Search API.
  • PHP:
  • Fixed an issue that causes script routing errors in the dev_appserver when the url regular expression uses subgroups that include a leading slash.

New in Google App Engine SDK 1.9.9 (Aug 13, 2014)

  • All:
  • TLS is now supported and enabled by default in the dev_appserver.
  • Fixed an issue with the Datastore Admin failing to load due to a DeadlineExceededError when retrieving kinds.
  • PHP:
  • Fixed an issue where form fields submitted with Google Cloud Storage upload may not get encoded correctly.

New in Google App Engine SDK 1.9.8 (Aug 1, 2014)

  • All:
  • Fixed an issue with Datastore Admin not properly restoring backups if writes are disabled.
  • Python:
  • Fixed an issue with NDB repeated, nested structures growing exponentially when saving.
  • PHP:
  • PHP is now updated to 5.4.30.

New in Google App Engine SDK 1.9.7 (Jul 17, 2014)

  • All:
  • Added memcache historical hit ratio to Admin Console dashboard
  • Fixed an issue with sockets connections timing out after 2 minutes
  • Fixed an issue with appcfg request_logs not working
  • Python:
  • Fixed an issue with the dev_appserver remove_ignored_dirs not working
  • PHP:
  • Fixed an issue with the dev_appserver directory separator for DOCUMENT_ROOT, SCRIPT_FILENAME, SCRIPT_NAME, and PHP_SELF not working on Windows
  • Fixed an issue with decrement not working in Memcache and Memcached

New in Google App Engine SDK 1.9.6 (Jun 4, 2014)

  • Python:
  • Django 1.5.4 has been upgraded to 1.5.8.
  • Django 1.4.3 has been upgraded to 1.4.13.
  • Fixed an issue with taskqueue_stub.py _Group.GetQueuesAsDict() raising TypeError intermittently.
  • Java:
  • Fixed an issue with the dev_appserver Search API for atom fields that contain whitespace or punctuation characters in their values (e.g., email addresses).
  • Fixed an issue with PermGen running out of space when using DeferredTasks in the dev_appserver.
  • Fixed an issue with date-valued HTTP headers such as If-Modified-Since getting a ClassCastException.
  • Fixed an issue with Datastore cursors in dev_appserver getting the wrong cursor value for keys only queries.
  • GO:
  • appengine/datastore - Support entity values whose underlying type is []byte.
  • appengine/search - Implement IDsOnly and Limit options for List and Search.

New in Google App Engine SDK 1.9.5 (May 22, 2014)

  • Python:
  • STARTTLS support for the dev_appserver is now available.
  • Fixed an issue with the Search API where searching for geo points whose distance from a fixed point is greater than some value returns documents that do not include that field.
  • Fixed an issue with the Search API where querying for a field that does not exist returns an error instead of returning zero matches on that field.
  • PHP:
  • Fixed an issue where certain legal Cloud Storage bucket names fail to validate.
  • Java:
  • Fixed an issue with the Search API where searching for geo points whose distance from a fixed point is greater than some value returns documents that do not include that field.
  • Fixed an issue with appstats generating a ClassCastException in the dev_appserver.
  • Fixed an issue with the dev_appserver Search API not finding atoms with spaces in them.
  • Fixed an issue with the Search API where querying for a field that does not exist returns an error instead of returning zero matches on that field.
  • GO:
  • appengine/datastore:
  • Add Query.EventualConsistency method for ancestor queries.
  • Change GeoPoint storage to be consistent with other runtimes.
  • Data stored before this release will have Lat and Lng reversed.

New in Google App Engine SDK 1.9.4 (May 2, 2014)

  • Python:
  • Fixed an issue with the Search API where it does not correctly parse expressions that use the subtraction operator without surrounding whitespaces.
  • Fixed an issue with the devappserver Search API allowing searches for a field with a negated value.
  • Fixed an issue with the devappserver Search API not handling searches for empty quotes the same way as production.
  • Fixed an issue with the devappserver Search API not matching documents with atom fields the same way as production.
  • Fixed an issue with the devappserver Search API allowing expressions that use the snippet operator over a numeric field.
  • Fixed an issue with the devappserver Search API allowing sorting expressions to use the snippet operator.
  • Fixed an issue with the devappserver Search API not validating that cursors are from a previous search.
  • Fixed an issue with the devappserver Search API not parsing queries that use the fuzzy search operator (~).
  • Fixed an issue with the devappserver Search API not validating the default value for sorting expressions on date fields.
  • Fixed an issue with the devappserver memcache viewer not displaying items with non-ASCII characters properly.
  • Fixed an issue with the devappserver allowing arbitrarily large file uploads using HTTP POST requests. It now matches production limits of 32MB.
  • Fixed an issue with NDB deserialization looping infinitely when nested value is None.
  • PHP:
  • Fixed an issue with libcurl giving a load error for Mac OS X Snow Leopard clients.
  • Fixed an issue with making simultaneous mysqli connections to the same CloudSQL instance causing the request to time out.
  • GO:
  • appengine/datastore - Add Key.Namespace method.
  • Java:
  • Speed up memcache API deserialization by using Class.forName instead of ClassLoader.loadClass.
  • Added client side deployment logging to Java appcfg, which will improve deployment performance of Java Applications.
  • Fixed an issue with Datastore Queries containing nonexisting fields returning no results instead of an error.
  • Fixed an issue with Datastore String properties so they are now

New in Google App Engine SDK 1.9.3 (Apr 16, 2014)

  • Python:
  • Fixed an issue with NDB deserialization going into an infinite loop when repeated nested structured properties are None.
  • PHP:
  • Fixed an issue with the fnmatch() function not being supported in production.
  • GO:
  • appengine/datastore - Support appengine.GeoPoint as an entity property type.
  • appengine/aetest - Removed aetest.Options.User and add aetest.Context.Login and aetest.Context.Logout.

New in Google App Engine SDK 1.9.2 (Apr 8, 2014)

  • All:
  • We are pleased to announce the availability of Dedicated Memcache service to our customers in the EU.
  • PHP
  • Users now have the ability to embed images in emails via the Content-Id attachment header.
  • The Zip module is now included in the SDK.
  • Fixed an issue with the Google Cloud Storage upload proxy truncating POST field data when it is longer than 80 characters.
  • Fixed an issue with default max sized uploads no longer handling unlimited size uploads.
  • GO:
  • appengine - Add GeoPoint type.
  • appengine/search - Support appengine.GeoPoint as a document field type.
  • Add FieldLoadSaver interface and FieldList type.

New in Google App Engine SDK 1.9.1 (Mar 21, 2014)

  • All:
  • The Performance Settings section of the Application settings page in the Admin Console, Backends API and all backends related management tools are now deprecated and will be removed in a future release. Users of Backends are recommended to migrate to the App Engine Modules API, which provides a more flexible implementation of the same functionality. These settings are now all configurable via Modules configuration files.
  • PHP:
  • Fixed an issue with ZendFramework causing App Engine project to crash when using APC caching.
  • Fixed an issue with URLFetch not sending strings with null characters correctly.
  • Fixed an issue with uploading files to a Google Cloud Storage failing in 1.9.0.
  • GO:
  • appengine/log - Add Record.InstanceID.

New in Google App Engine SDK 1.9.0 (Feb 28, 2014)

  • All:
  • Modules Service API and application management features are now GA.
  • New App Engine Application Identifiers must now start with a letter, in addition to the existing requirements that the identifier be 6-30 characters which are letters, numbers, and hyphens, and not start or end with a hyphen.
  • Python:
  • The size limit on the Search API is now computed and enforced on a per-index basis, rather than for the app as a whole. The per-index limit is now 10GB. There is no fixed limit on the number of indexes, or on the total amount of Search API storage an application may use.
  • Newly created App Engine applications now have a Google Cloud Storage bucket created automatically as part of the same Google Cloud Project. /activate#Using_the_default_Gcs_bucket
  • Users now have the ability to embed images in emails via the Content-Id attachment header.
  • Removed deprecated modules.py methods start_module, start_module_async, stop_module, stop_module_async get_modules_async, get_versions_async, get_default_version_async, get_num_instances_async, and get_hostname_async.
  • Fixed an issue with NDB backup/restore corrupting certain compressed entities.
  • PHP:
  • The PHP interpreter has been upgraded from PHP 5.4.19 to PHP 5.4.22.
  • Autoloading is now available in the SDK so developers will no longer need to explicitly require SDK files.
  • Expanded php.ini setting google_appengine.allow_include_gs_buckets to allow a path filter to be included for improved security.
  • Newly created App Engine applications now have a Google Cloud Storage bucket created automatically as part of the same Google Cloud Project.
  • An "E_USER_WARNING" warning message is now triggered if an application moves a user uploaded file to a Google Cloud Storage bucket/path. This is due to the fact that code may be included and lead to a local file inclusion vulnerability.
  • Added API functions CloudStorageTools::getMetadata() and CloudStorageTools::getContentType() for retrieving the metadata and content type of Google Cloud Storage objects.
  • Fixed an issue with empty Google Cloud Storage folders not displaying correctly in the Developers Console. New folders are now created using the "/" suffix instead of "$folder" so that they are displayed correctly.
  • Fixed an issue with PHP_SELF and SCRIPT_NAME not being implemented correctly.

New in Google App Engine SDK 1.8.9 (Jan 16, 2014)

  • All:
  • Renamed appcfg start to appcfg start_module_version and stop to stop_module_version.
  • Fixed an issue with ID allocation collisions in the Datastore.
  • Fixed an issue with Cloud Storage calls failing in the dev_appserver.
  • Fixed an issue with the dev_appserver not starting on Windows when using versions of Python earlier than 2.7.2.
  • Python :
  • Deprecated start_module, start_module_async, stop_module, stop_module_async get_modules_async, get_versions_async, get_default_version_async, get_num_instances_async, get_hostname_async and added start_version, start_version_async, stop_version, stop_version_async as replacements in the Modules API.
  • Added verbose_name support for ComputedProperty in NDB.
  • Fixed an issue with deffered.defer not waiting for async operations.
  • Fixed an issue with LocalStructureProperty not handling None value in NDB.
  • Fixed an issue NDB not working with sqlite.
  • Fixed an issue with debug not working with PyDev in 1.8.8.
  • Fixed an issue with object properties not being retrieved in NDB.
  • PHP:
  • Renamed startModule, stopModule to startVersion, stopVersion in the Modules API.
  • Added support for the ftp extension.
  • Added support for the zip extension.
  • Added support for the gethostname() function.
  • A proper "billing required" message is now given when users attempt to use Sockets API on free apps.
  • Fixed an issue with header keys and values having whitespaces preventing responses from being compressed.
  • Fixed an issue with content-type and metadata not being updated when renaming Google Cloud Storage objects.
  • Fixed an issue with Cloud Storage rename requests failing when an object has a space in its name.
  • Java:
  • Renamed appcfg start to appcfg start_module_version and stop to stop_module_version.
  • The following methods are deprecated in the Modules API and will be removed in an upcoming release:
  • getModulesAsync
  • getVersionsAsync
  • getDefaultVersionAsync
  • getNumInstancesAsync
  • getVersionHostnameAsync
  • getInstanceHostnameAsync
  • startModule (replaced by startVersion)
  • startModuleAsync (replaced by startVersionAsync)
  • stopModule (replaced by stopVersion)
  • stopModuleAsync (replaced by stopVersionAsync)
  • getModuleHostname (replaced by getVersionHostname and getInstanceHostname)
  • getModuleHostnameAsync
  • The following exceptions have been deprecated in the Modules API and will be removed in a following release:
  • InvalidInstanceException
  • InvalidModuloeException
  • InvalidVersionException
  • The following exceptions have been removed in the Modules API:
  • ModuleAlreadyStartedException
  • ModuleAlreadyStoppedException
  • Modules are now supported in the dev_appserver Development Console.
  • Fixed an issue with ID allocation collisions in the Datastore.
  • GO:
  • appengine/remote_api - Add NewRemoteContext function.

New in Google App Engine SDK 1.8.8 (Dec 7, 2013)

  • All:
  • Dedicated Memcache is now a GA feature. Our deprecation policy applies and customers are encouraged to use this feature in production.
  • Memcache API calls are tracked by a new metric that estimates resource usage, Memcache Compute Units (MCU's). There is a new quota bucket and dashboard graph corresponding to the metric, as well as an option in the memcache viewer to display top keys by MCU's.
  • The dev_appserver logs.db format is not backward compatible with 1.8.7. Users that revert to the 1.8.7 dev_appserver after trying 1.8.8 must delete this file. Unless specifically named by the user in the command line, the file is found at /tmp//logs.db. The error seen if this file is not removed is: 'IntegrityError: RequestLogs.module may not be NULL'
  • Added /ah/gcs endpoint on the dev_appserver for local emulation of Google Cloud Storage services.
  • Fixed an issue with users receiving errors when uploading large files to GCS.
  • Fixed an issue with cloning apps not creating proper service account names.
  • Python:
  • Fixed an issue with the dev_appserver app id validation for UTF-8
  • PHP:
  • The Sockets API is now available for Billing Enabled Applications.
  • PHP String has been added as a key type in the Admin Console Memcache viewer.
  • Added CloudStorageTools::getPublicUrl() method for constructing URLs for Google Cloud Storage objects.
  • Opening GCS objects in text mode is now supported.
  • A false error is now returned if stream_cast is called on a GCS stream.
  • Java:
  • Dedicated Memcache is now a GA feature. Our deprecation policy applies and customers are encouraged to use this feature in production.
  • Memcache API calls are tracked by a new metric that estimates resource usage, Memcache Compute Units (MCU's). There is a new quota bucket and dashboard graph corresponding to the metric, as well as an option in the memcache viewer to display top keys by MCU's.
  • Fixed an issue with cloning apps not creating proper service account names.
  • Fixed an issue with users receiving errors when uploading large files to GCS.
  • GO:
  • appengine/mail - Add Attachment.ContentID field.

New in Google App Engine SDK 1.8.7 (Nov 6, 2013)

  • All:
  • Cloud Endpoints is now a GA feature.
  • Memcache configuration changes and mutations (flush, set, etc.) made from the Admin Console are now recorded in the admin console logs.
  • The max_concurrent_requests setting is now configurable per version/module.
  • Fixed an issue with Datastore not correctly validating namespaces with greater than 500 characters.
  • Python:
  • Fixed an issue with NDB not returning the same instance for async gets when using memcache.
  • PHP:
  • Added support for the mcrypt PHP extension to the PHP interpreter included with the Mac OSX SDK.
  • Added support for the zlib extension library to the PHP interpreter included with the Mac OSX SDK.
  • Added support for the PHP gd extension to the PHP interpreter included with the Mac OSX SDK.
  • Fixed an issue where blank multipart form values are uploaded incorrectly into Google Cloud Storage.
  • Fixed an issue where PHP applications could not be run locally using the Mac OS X launcher on Mac OS X Lion and earlier.
  • Java:
  • Cloud Endpoints is now a GA feature.
  • Memcache configuration changes and mutations (flush, set, etc.) made from the Admin Console are now recorded in the admin console logs.
  • The max_concurrent_requests setting is now configurable per version/module.
  • LogService API functions related to the modules feature will be changing.
  • The following functions will be deprecated and new versions will be provided: LogQuery.getModuleVersions(), LogQuery.moduleVersions() and LogQuery.Builder.withModuleVersions().
  • The following functions will be removed in a future release: LogQuery.getModuleVersions(), LogQuery.moduleVersions(), LogQuery.Builder.withModuleVersions(), LogQuery.getServerVersions(), LogQuery.serverVersions() and LogQuery.Builder.withServerVersions(). Serialized LogQuery objects with values set using any of the above removed methods will not be supported in a future release.
  • Fixed an issue with Datastore not correctly validating namespaces with greater than 500 characters.
  • Fixed and issue with vacuum_indexes not working in the SDK.
  • Go:
  • appengine/socket:
  • Add SetContext method.
  • Other:
  • Support goapp serve and goapp deploy.

New in Google App Engine SDK 1.8.6 (Oct 16, 2013)

  • All:
  • A memcache size chart has been added to admin console's dashboard. Access it via the drop-down above the graph. The chart graphs memcache size over time enabling customers to determine when cache flush events occurred. This is a preview feature.
  • Fixed an issue with the dev_appserver that allows an invalid Datastore query combination of group by and filter properties.
  • Fixed an issue with the bulkloader that causes uploads to the dev_appserver to fail.
  • Fixed an issue affecting validation of the size of Datastore property names.
  • Fixed an issue with Datastore query validation for strings with exactly 500 characters.
  • Python:
  • Django 1.5.4 is now available in the Runtime. This is a Preview feature.
  • app_identity.get_access_token in the App Identity API is now a GA feature.
  • Geo is now a supported field type in the Search API for the dev_appserver.
  • PHP:
  • php://memory and php://temp I/O streams are now supported.
  • GO:
  • appengine: Add ModuleName and ModuleHostname functions.
  • appengine/aetest: New package for testing with a local api_server.py.
  • appengine/module: New package.
  • appengine/search: Add Index.List method and ListOptions.StartID field.
  • Add Iterator.Count method.
  • Other: Support "goapp build", "goapp install", and "goapp test".
  • Java:
  • GetAccessToken in the OAuth package is now a GA feature.
  • The LogsService API functions related to the Modules feature will be changing as follows:
  • The following functions will be deprecated and new versions will be provided: LogQuery.getModuleVersions(), LogQuery.moduleVersions() and LogQuery.Builder.withModuleVersions().
  • The following functions will be removed in an upcoming release: LogQuery.getModuleVersions(), LogQuery.moduleVersions() and LogQuery.Builder.withModuleVersions(), LogQuery.getServerVersions(), LogQuery.serverVersions() and LogQuery.Builder.withServerVersions(). Serialized LogQuery objects with values set using any of the above removed methods will not be supported in an upcoming release.
  • The Cloud Endpoints API @ApiSerializer has been renamed to @ApiTransformer and the Serializer interface has been renamed to Transformer. @ApiSerializationProperty has also been renamed to @ApiResourceProperty.
  • If a customer passes invalid data to a memcache put() call, they now see a more useful error message.

New in Google App Engine SDK 1.8.5 (Sep 27, 2013)

  • All:
  • The Search API is now a GA feature.
  • Fixed an issue with the dev_appserver Datastore where UTF-8 validation did not occur on string values.
  • Fixed an issue with the Admin Console Datastore Viewer throwing errors when fetching UTF-8 kinds.
  • Fixed an issue with the Datastore Admin not being able to backup to another app.
  • Fixed an issue where files that contain an '@' could not be deployed.
  • Python:
  • Developers can now use pdb when debugging python applications in the dev_appserver.
  • PHP:
  • Modules are now supported for the PHP Runtime.
  • The Log Service API is now available.
  • The PHP interpreter has been upgraded from PHP 5.4.17 to PHP 5.4.19.
  • The /e modifier for mb_ereg_replace has been disabled.
  • The PHP interpreter has been switched to the JSON-C library.
  • The Mac OSX SDK now includes a PHP interpreter, installing PHP separately is no longer required.
  • The Windows SDK now includes a PHP interpreter, installing PHP separately is no longer required.
  • GO:
  • appengine - Add PublicCertificates function.
  • appengine/conversion - Remove package.
  • appengine/search - Add namespace support.
  • appengine/taskqueue - Add ErrTaskAlreadyAdded var.
  • Java:
  • The Conversion API, a decommissioned feature, has been removed from the runtime. Applications in production that import the API should be fixed as soon as possible.

New in Google App Engine SDK 1.8.4 (Sep 10, 2013)

  • All:
  • A Datastore Admin fix in this release improves security by ensuring that scheduled backups can now only be started by a cron or task queue task. Administrators can still start a backup by going to the Datastore Admin in the Admin Console.
  • Python:
  • Better support is now provided for the _$folder$ magic cloud storage keyword, and the implementation of basic mkdir()/rmdir() functionality via GCS streams.
  • This release adds the wrappers @transactional_async and @transactonal_tasklet to correct (a) @transactional @tasklet being synchronous despite the decorator, and (b) @tasklet @transactional not running the generator in a transaction.
  • Fixed a unicode issue associated with expressions in the Search API. A search with snippeted fields was failing on documents containing unicode characters.
  • Fixed an issue with the dev_appserver not auto-detecting the lib/ directory in the SDK.
  • Fixed an issue where Blobstore usage was being charged even though the actual data was being stored in Cloud Storage. All affected developers have been informed and reimbursements are underway.
  • Fixed an issue that ensures all .py files in google.appengine.api that are available in the SDK are also available in the runtime.
  • Fixed an issue of warning messages being displayed when running appcfg update (eg. appcfg.py update . --oauth2) from the 1.8.3 Python SDK. The appengine_rpc_httplib2 will work without warnings regardless of which oauth2client library is being used.
  • PHP:
  • The PHP interpreter was upgraded from PHP 5.4.8 to PHP 5.4.17.
  • The is_writable() method now supports Google Cloud Storage files and buckets.
  • You no longer need to specify the PHP runtime on the command line when deploying applications via appcfg.py
  • Backends are disabled for PHP and are no longer supported with the PHP runtime.
  • Upload of PHP apps now ignores any pre-compilation errors. This allows precompilation to be disabled on a per-runtime basis, and defaults to disabled for PHP.
  • Fixed an issue where SYSTEMROOT was not passed to the environment checking script thereby not recognizing the PHP intepreter for Windows in the SDK.
  • GO:
  • appengine/search: New package.
  • Java:
  • The Java SDK local datastore now defaults to an HRD-like consistency policy, including eventually consistent global queries.
  • The Conversion API, a decommissioned feature, has been removed from the SDK. In the next release, the API will be removed from the runtime and any attempt to import the API will raise an exception. Applications in production that import the API should be fixed as soon as possible.
  • Fixed the implementation of the Cloud SQL JDBC driver for App Engine which restricted the connection lifetime to the lifetime of the HTTP request. This will unblock users who want to use long running connections (e.g. in connection pools).
  • Fixed bulkloader issue for Java caused by improper updates of the Java Remote API handlers in a previous version of the runtimes.
  • Fixed Eclipse plugin on the development server to eliminate complaints about missing indexes when using equality filters.
  • Fixed the issue with SASL provider registration that was impacting developers' ability to connect to GMail via IMAP.

New in Google App Engine SDK 1.8.3 (Aug 7, 2013)

  • Python:
  • Published a major rewrite of the Search API documentation. Please see: https://developers.google.com/appengine/docs/python/search/
  • Interfacing into the Task Queue REST API no longer requires including "s~" at the beginning of the project name.
  • Fixed an issue with the Mail API, email addresses that contain encoded newlines as specified in rfc2047 are now parsed correctly.
  • Fixed an issue with channels.send_message failing when a client id has 3 or more dashes.
  • Fixed an issue with ndb.non_transactional correctly restoring the db library's transactional state.
  • Fixed an issue with NDB raising the correct exception when the rollback itself has an exception.
  • The NDB model property settings 'default' and 'required' are no longer mutually exclusive.
  • Fixed an issue with debugger/breakpoint not working on the dev_appserver.
  • Fixed an issue with NDB queries supporting iterate over distinct queries.
  • Fixed an issue with enabling cloud integration for existing apps.
  • Fixed an issue with users not being able to view the cron jobs page in the dev_appserver.
  • Fixed an issue with the Channel API send_message function not working on the dev_appserver.
  • Fixed an issue with Modules get_current_module_name() incorrectly reporting as default when it is not.
  • Fixed an issue with the Datastore Admin UI failing to load due to the app having too many kinds.
  • Fixed an issue with the Channel API Testbed not working correctly after upgrading to SDK 1.8.2
  • PHP:
  • Users who are whitelisted to use PHP are now able to deploy PHP to any of their apps.
  • There is now better support for stat() related functions for Google Cloud Storage objects.
  • Added a read through cache to the GCS client to improve performance. This allows for optimistic caching for write-once, read-many applications and performs on-write invalidation.
  • Environment variables that are set in app.yaml are now available in the PHP runtime.
  • You can now pass an array of metadata as part of the Google Cloud Storage upload context.
  • Apps can now use opendir()/readdir()/rewinddir()/closedir() on Google Cloud Storage buckets.
  • The PHP Task Queue API now supports adding tasks in bulk via the addTasks() method on the new PushQueue class.
  • The PHP Task Queue API now supports setting headers on the PushTask class.
  • Interfacing into the Task Queue REST API no longer requires including "s~" at the beginning of the project name.
  • Fixed an issue with the Mail API, email addresses that contain encoded newlines as specified in rfc2047 are now parsed correctly.
  • Fixed an issue with enabling cloud integration for existing apps.
  • Java:
  • Fixed an issue with the Local Channel service failing to properly validate tokens.
  • Go SDK:
  • appengine - Add IsTimeoutError function.
  • appengine/cloudsql - New package for CloudSQL support.
  • appengine/datastore - Reject datastore keys, property names, or property string values that are not valid UTF-8.

New in Google App Engine SDK 1.8.2 (Jul 17, 2013)

  • Java:
  • This SDK will be the last release that can deploy Java 6 apps. In 1.8.2, the SDK will only be compiled with the Java 7 compiler and the only target runtime will be Java 7.
  • The Task Queue async API is now a GA feature. The asynchronous methods improve utilization by allowing your app to add, lease and delete multiple tasks in parallel.
  • Cloud Console projects are now created by default whenever a new App Engine app is created. This is a Preview feature.
  • In an upcoming release the Experimental Google Cloud Storage API and Files API within the Blobstore service will be decommissioned.
  • The Google Cloud Storage library will replace Google Cloud Storage API and is now available as a Preview feature.
  • Bandwidth between App Engine and Google Cloud Storage is currently free of charge (this may change in the future for certain levels of service).
  • The Search API has graduated from Experimental to Preview. Apps that have billing enabled can exceed the free quota levels and will be charged for usage above these levels.
  • Estimated number of search results will only be accurate if it is less than or equal to the number of results requested. By default this can be overridden by setting number_found_accuracy QueryOption in the Search API.
  • Dates, atoms, and number fields can now be found by searching without a field restriction in the Search API.
  • A quoted empty string now returns atom fields with empty values for the Search API.
  • Snippet and count functions are no longer allowed in sort expressions for the Search API.
  • The Search API now has improved error messages for user errors and internal errors.
  • The Datastore now assigns scattered auto ids by default. Legacy auto ids are still available via the auto_id_policy option in appengine-web.xml.
  • The Sockets API now allows client code to call get/set options against sockets. Previously, calls raised "Not Implemented" exceptions. When java.net.Socket.get() is called, a mock value is returned, calls to set() will be silently ignored.
  • Fixed an issue with the namespace not being displayed when a user attempts to select a namespace in the Admin Console.
  • Fixed an issue in the Admin Console Logs page to correctly display Until instead of Since for logs search criteria.
  • Python:
  • App Engine now supports deployment of applications via the Git tool. Once you complete the initial setup steps, you will be ready to deploy apps with the same ease you push code to a git repository using % git push appengine master. This is a Limited Preview feature.
  • The Datastore now assigns scattered auto ids by default. Legacy auto ids are still available via the auto_id_policy option in app.yaml.
  • The Sockets API now allows client code to call get/set options against sockets. Previously, calls raised Not Implemented exceptions. For supported options, calls to getsockopt will return a mock value and calls to setsockopt will be silently ignored. Errors will continue to be raised for unsupported options. The currently supported options are: SO_KEEPALIVE, SO_DEBUG, TCP_NODELAY, SO_LINGER, SO_OOBINLINE, SO_SNDBUF, SO_RCVBUF, and SO_REUSEADDR.
  • Updated skip_files documentation to reflect the new default.
  • The ndb library now supports distinct queries. This is a Preview feature.
  • Fixed an issue with Google Cloud Storage objects not being compatible across various APIs on the dev_appserver.
  • PHP:
  • Enabled the Mcrypt extension.
  • Enabled the iconv extension.
  • Enabled the mbstring extension.
  • It is now possible to include/require files from Google Cloud Storage using the google_app_engine.allow_include_gs_buckets ini setting.
  • Basic support for url_stat() with Cloud Storage Streams is now provided. This means that many standard filesystem functions such as is_file(), is_readable(), is_writeable(), filesize(), etc now work with Cloud Storage objects.
  • Honor the default_stream_context for Google Cloud Storage streams when writing new objects.
  • Added deleteImageServingUrl() method to the CloudStorageTools class.
  • The createGsKey() method of CloudStorageTools has been made private.
  • Fixed a bug where $_SERVER['PHP_SELF'] was including the query string.
  • App Engine now supports deployment of applications via the Git tool. Once you complete the initial setup steps, you will be ready to deploy apps with the same ease you push code to a git repository using % git push appengine master. This is a Limited Preview feature.
  • Updated skip_files documentation to reflect the new default.
  • Removed the NotAllowedError, RedirectTooLongError, and UserNotFoundError exception classes from the Users API. Their use is replaced by throwing a UsersException or InvalidArgumentException as appropriate.
  • Removed the Capability API.
  • Fixed an issue with Google Cloud Storage objects not being compatible across various APIs on the dev_appserver.
  • Go SDK:
  • This release is based on Go 1.1.
  • appengine/blobstore:
  • Add StorageBucket to UploadURLOptions struct.
  • appengine/datastore:
  • Allow Property.Value to be the nil interface value, for compatibility with datastore entities created by other languages.
  • Support Projection and Distinct Projection queries.
  • appengine/memcache:
  • Stop populating Expiration field of fetched items.

New in Google App Engine SDK 1.8.1 (Jun 18, 2013)

  • Python:
  • The Task Queue async API is now a GA feature. The asynchronous methods improve utilization by allowing your app to add, lease and delete multiple tasks in parallel.
  • Cloud Console projects are now created by default whenever a new App Engine app is created. This is a Preview feature.
  • In an upcoming release the Experimental Google Cloud Storage API Functions will be decommissioned.
  • The Google Cloud Storage library will replace Google Cloud Storage API and is now available as a Preview feature.
  • Bandwidth between App Engine and Google Cloud Storage is currently free of charge (this may change in the future for certain levels of service).
  • The Search API has graduated from Experimental to Preview. Apps that have billing enabled can exceed the free quota levels and will be charged for usage above these levels.
  • Estimated number of search results will only be accurate if it is less than or equal to the number of results requested. By default this can be overridden by setting number_found_accuracy QueryOption in the Search API.
  • Dates, atoms, and number fields can now be found by searching without a field restriction in the Search API.
  • A quoted empty string now returns atom fields with empty values for the Search API.
  • Snippet and count functions are no longer allowed in sort expressions for the Search API.
  • The Search API now has improved error messages for user errors and internal errors.
  • App Engine now supports deployment of applications via the Git tool. Once you complete the initial setup steps, you will be ready to deploy apps with the same ease you push code to a git repository using % git push appengine master. This is a Limited Preview feature. You may request access via the following link: https://docs.google.com/a/google.com/forms/d/1aLaAOZb_cXFiVqzLAMvPV9kh0FmvlLRUbwD-LBbLuUI/viewform
  • The Datastore now assigns scattered auto ids by default. Legacy auto ids are still available via the auto_id_policy option in app.yaml.
  • The Sockets API now allows client code to call get/set options against sockets. Previously, calls raised Not Implemented exceptions. For supported options, calls to getsockopt will return a mock value and calls to setsockopt will be silently ignored. Errors will continue to be raised for unsupported options. The currently supported options are: SO_KEEPALIVE, SO_DEBUG, TCP_NODELAY, SO_LINGER, SO_OOBINLINE, SO_SNDBUF, SO_RCVBUF, and SO_REUSEADDR.
  • Updated skip_files documentation to reflect the new default.
  • The ndb library now supports distinct queries. This is a Preview feature.
  • Fixed an issue with Google Cloud Storage objects not being compatible across various APIs on the dev_appserver.
  • Fixed an issue with the namespace not being displayed when a user attempts to select a namespace in the Admin Console.
  • Fixed an issue in the Admin Console Logs page to correctly display Until instead of Since for logs search criteria.
  • PHP:
  • Enabled the Mcrypt extension.
  • Enabled the iconv extension.
  • Enabled the mbstring extension.
  • It is now possible to include/require files from Google Cloud Storage using the google_app_engine.allow_include_gs_buckets ini setting.
  • Basic support for url_stat() with Cloud Storage Streams is now provided. This means that many standard filesystem functions such as is_file(), is_readable(), is_writeable(), filesize(), etc now work with Cloud Storage objects.
  • Honor the default_stream_context for Google Cloud Storage streams when writing new objects.
  • Added deleteImageServingUrl() method to the CloudStorageTools class.
  • The createGsKey() method of CloudStorageTools has been made private.
  • Fixed a bug where $_SERVER['PHP_SELF'] was including the query string.
  • App Engine now supports deployment of applications via the Git tool. Once you complete the initial setup steps, you will be ready to deploy apps with the same ease you push code to a git repository using % git push appengine master. This is a Limited Preview feature. You may request access via the following link: https://docs.google.com/a/google.com/forms/d/1aLaAOZb_cXFiVqzLAMvPV9kh0FmvlLRUbwD-LBbLuUI/viewform
  • Updated skip_files documentation to reflect the new default.
  • Removed the NotAllowedError, RedirectTooLongError, and UserNotFoundError exception classes from the Users API. Their use is replaced by throwing a UsersException or InvalidArgumentException as appropriate.
  • Removed the Capability API.
  • Fixed an issue with Google Cloud Storage objects not being compatible across various APIs on the dev_appserver.
  • Java:
  • This SDK will be the last release that can deploy Java 6 apps. In 1.8.2, the SDK will only be compiled with the Java 7 compiler and the only target runtime will be Java 7.
  • The Task Queue async API is now a GA feature. The asynchronous methods improve utilization by allowing your app to add, lease and delete multiple tasks in parallel.
  • Cloud Console projects are now created by default whenever a new App Engine app is created. This is a Preview feature.
  • In an upcoming release the Experimental Google Cloud Storage API Functions will be decommissioned.
  • The Google Cloud Storage library will replace Google Cloud Storage API and is now available as a Preview feature.
  • Bandwidth between App Engine and Google Cloud Storage is currently free of charge (this may change in the future for certain levels of service).
  • The Search API has graduated from Experimental to Preview. Apps that have billing enabled can exceed the free quota levels and will be charged for usage above these levels.
  • Estimated number of search results will only be accurate if it is less than or equal to the number of results requested. By default this can be overridden by setting number_found_accuracy QueryOption in the Search API.
  • Dates, atoms, and number fields can now be found by searching without a field restriction in the Search API.
  • A quoted empty string now returns atom fields with empty values for the Search API.
  • Snippet and count functions are no longer allowed in sort expressions for the Search API.
  • The Search API now has improved error messages for user errors and internal errors.
  • The Datastore now assigns scattered auto ids by default. Legacy auto ids are still available via the auto_id_policy option in appengine-web.xml.
  • The Sockets API now allows client code to call get/set options against sockets. Previously, calls raised "Not Implemented" exceptions. When java.net.Socket.get() is called, a mock value is returned, calls to set() will be silently ignored.
  • Fixed an issue with the namespace not being displayed when a user attempts to select a namespace in the Admin Console.
  • Fixed an issue in the Admin Console Logs page to correctly display Until instead of Since for logs search criteria.
  • Go SDK:
  • This release is based on Go 1.1.
  • appengine/blobstore:
  • Add StorageBucket to UploadURLOptions struct.
  • appengine/datastore:
  • Allow Property.Value to be the nil interface value, for compatibility with datastore entities created by other languages.
  • Support Projection and Distinct Projection queries.
  • appengine/memcache:
  • Stop populating Expiration field of fetched items.

New in Google App Engine SDK 1.8.0 (May 9, 2013)

  • Python SDK changes:
  • The Mail API now allows attachments with .zip and .gzip extensions as long as the archives do not contain entries with blacklisted extensions.
  • New Billing Enabled apps will no longer default to an email quota of 20,000 per day. Instead, apps will need to file a request through the admin console to get email quotas increased.
  • Admin console dashboard charts and reports for all users have been fully migrated to the new, more reliable backend announced in 1.7.6.
  • The maximum size of POST requests made through URLfetch has been increased from 5MB to 10MB.
  • Fixed an issue with the Mail API to prevent sending mail from a Google Apps mail account that has been suspended.
  • Fixed an issue with the admin handler of the new dev_appserver failing to import appengine_config automatically.
  • Java SDK changes:
  • The Mail API now allows attachments with .zip and .gzip extensions as long as the archives do not contain entries with blacklisted extensions.
  • New Billing Enabled apps will no longer default to an email quota of 20,000 per day. Instead, apps will need to file a request through the admin console to get email quotas increased.
  • Admin console dashboard charts and reports for all users have been fully migrated to the new, more reliable backend announced in 1.7.6.
  • The maximum size of POST requests made through URLfetch has been increased from 5MB to 10MB.
  • Fixed an interaction issue between the Java MapReduce library and the Files API which causes loss of data. If you are using the experimental Java MapReduce library, we strongly encourage you to update to the latest version of the library in the public svn:
  • Fixed an issue with the Mail API to prevent sending mail from a Google Apps mail account that has been suspended.
  • Fixed an issue that caused Full-Text Search to fail in the Java dev_appserver.
  • Fixed an issue with Java dev_appserver which caused the AdWords API to not work.
  • Fixed an issue with the Java SDK jar file being too large for Windows 64.
  • Fixed a JAXBPermission.setDatatypeConverter permission issue in Java7 runtime.
  • Go SDK changes:
  • appengine/blobstore:
  • Add BlobKeyForFile function.
  • appengine/mail:
  • Add SendToAdmins function.
  • appengine/taskqueue:
  • Permit "" as an alias for the default queue throughout.
  • Deprecate the maxTasks argument of QueueStats; it is now ignored.

New in Google App Engine SDK 1.7.7 (Apr 10, 2013)

  • The Sockets API, which allows applications to make outgoing TCP connections and send/receive UDP packets to the Internet using both IPv4 and IPv6, is now available as an experimental feature for billed apps.
  • The ftplib module is now restored. It depends on the experimental Sockets API.
  • Billing enabled apps will no longer be subject to a $2.10 minimum weekly spend. Instead, apps will only be charged for their actual usage.
  • Matplotlib 1.1.1, an experimental feature, is being deprecated and will be removed in 1.7.8. Please switch to matplotlib 1.2.0.
  • Fixed an issue where the dev_appserver Datastore auto ids assigned by the scattered id policy were too large to be represented as floating point numbers.
  • Fixed an issue where the dev_appserver threw an exception on any Search API call that used an index that was originally created as GLOBALLY consistent.
  • Fixed an issue with NDB not serializing projection entities correctly.
  • Fixed an issue with NDB not projecting structured properties correctly.
  • Fixed an issue with task queues failing to resolve backend addresses in the new dev_appserver.
  • Fixed an issue with the Search API allowing multiple documents with no IDs to be in one put request.
  • Fixed an issue with sort by doc_id not translating correctly causing InvalidRequest errors on the Search API.
  • Fixed an issue with the Search admin UI where an Internal Server Error was served.
  • Fixed an issue with Prospective Search failing in the new dev_appserver.
  • Fixed an issue with the new dev_appserver failing with ImportError.
  • Fixed an issue with Sqlite3 being unable to open a database file in the new dev_appserver.
  • Fixed an issue with serving urls that contain unicode characters in the new dev_appserver.

New in Google App Engine SDK 1.7.6 (Mar 20, 2013)

  • The new and improved development appserver, which was previewed last release, now becomes the default. The old development appserver has been renamed to old_appserver.py and will remain available until the first release after 1 July 2013 when it will be removed from the SDK.
  • A Go runtime has been added to the new and improved development appserver.
  • The Debug log level for the runtime has been enabled.
  • Improvements to the App Engine billing system will be rolled out gradually to all apps.
  • The application summary no longer displays the default version of a running application, instead it lists the application as 'RUNNING'. In an upcoming release applications will have multiple logical sub components, each of which will have a default version. This UI update is meant to align with this functionality.
  • Projection queries are now a fully supported GA feature.
  • The XMPP API now has multi-JID get_presence. This provides the ability to get the availability of multiple users.
  • Django 1.4 and Webob 1.2.3 are now promoted to GA.
  • Apps now have the ability to fopen() files that are declared as static files in app.yaml using the application_readable flag.
  • The dev_appserver now allocates automatic ids using the 'scattered' id allocation policy by default.
  • Admin console dashboard charts and current load/errors reports will be moving to a new, more reliable backend. The change will be gradually rolling to users of admin console over the next few weeks.
  • New Search API quotas are now displayed in the Admin Console. These quotas are not currently enforced, but will be part of the pricing model for the Search API in a future release.
  • The experimental Search API's ability to explicitly sort search results by SortExpression.RANK_FIELD_NAME (i.e. order_id) field in ascending order has been removed.
  • Globally consistent indexes in the experimental Search API are now deprecated and will be removed in the next release.
  • Task Queue tasks may now be added and deleted asynchronously. This allows applications to perform common task queue operations without blocking. This is an experimental feature.
  • In the experimental MapReduce framework, shards that encounter Files API errors will retry three times before the entire job fails.
  • Google Protocol RPC now supports deserializing and reserializing of unexpected fields.
  • A new Google Protocol RPC field type for supporting datetime values has been added.
  • Fixed an issue which caused an incorrect server error message when setting the default version on the admin console, though the version was set correctly.
  • Fixed an issue where get_indexes() didn't correctly populate the namespace when run from the new dev_appserver.
  • Fixed an issue with the new dev_appserver failing on invalid login cookies. It now uses type="email" for email in the login form.
  • Fixed an issue with the new dev_appserver to have fix_sys_path add the necessary libraries to sys.path making it now compatible with the testbed.

New in Google App Engine SDK 1.7.5 (Feb 14, 2013)

  • New instance classes F4_1G and B4_1G are now available. These instances have compute capacity equal to F4/B4 but with a maximum of 1G RAM instead of 512MB.
  • The Logs API stub now uses sqlite in the dev_appserver. Please note that the --persist_logs flag is still needed in order for logs to be saved.
  • The deprecated classes and functions AddError, AddResult, ListIndexesResponse, ListResponse, RemoveError, RemoveResult, and list_indexes were removed from the Search API in the SDK. If your app references any of these classes or functions, you must deploy a new version without these references before the next release of App Engine. If you do not do this, your app may stop working in production.
  • The Conversion API, which was decommissioned last release, has been removed from the SDK. In a future release, the API will be removed from the runtime and any attempt to import the library will raise an exception. Applications in production that import the library should be fixed as soon as possible.
  • Matplotlib v1.2.0 is now available as an experimental feature.
  • Django 1.4 has been upgraded to 1.4.3. This is an experimental feature.
  • We are including a preview of a new and improved version of our development server. The new version is faster, provides more faithful support for complex multi-threaded applications, has better support for Datastore and supports more libraries. Try dev_appserver2.py in the SDK. This is an experimental feature.
  • The Channel API now has the ability to send channel messages from any app version or backend regardless of where the channel was created.
  • The URL Fetch service now supports PATCH method requests.
  • The Mail API can now send mail bounce notifications to the app. The notification will be delivered to /_ah/bounce if mail_bounce inbound services are enabled.
  • The Blobstore service now returns the created filename instead of the blobKey when using Cloud Storage
  • Fixed an issue with os.urandom throwing an exception in dev_appserver2 when using OS X.
  • Fixed an issue with time.tzset not existing in dev_appserver2 for Windows.

New in Google App Engine SDK 1.7.4 (Dec 14, 2012)

  • Background threads is now a GA feature.
  • Traffic Splitting is now a GA feature.
  • Task Queue Statistics is now a GA feature.
  • Logs API now has the ability to fetch requests based on a list of request_ids. Currently, this only works in production and is not supported in dev_appserver.
  • Python Interpreter has been upgraded to 2.7.3.
  • WebOb 1.2.3 is now available for Python 2.7. Users using the undocumented 1.2.2 should update their app, since that version will be removed in the next release.
  • DISTINCT for Datastore queries is now available as an experimental feature.
  • Matplotlib v1.1.1 is now available as an experimental feature.
  • The decommissioned Conversion API has been removed.
  • Added a warning that the interactive console will be disabled if a user runs dev_appserver with the --address flag.
  • JSON properties are now restrictable to list or dictionaries in NDB.
  • Users can now set how many columns can be viewed in the Datastore Viewer via a drop-down menu which customizes the number of columns displayed.
  • Fixed an issue with expandos throwing an error when containing nested expandos in NDB.
  • Fixed an issue with properties not being added to structured properties in NDB.
  • Fixed an issue with PyCrypto raising an ImportError when installing globally into site-packages.
  • Fixed an issue with PyCrypto not working with OSX 10.8 or Ubuntu Precise.
  • Fixed an issue with backends.get_instance returning thread ID instead of integer instance ID in production.
  • Fixed an issue with Datastore Backup failing when a schema has a very large number of properties.
  • Fixed an issue with dev_appserver not reloading changed code.
  • Fixed an issue with custom ordered queries not working using sqlite on the dev_appserver.
  • Fixed an issue with users being unable to change Authentication Type after app creation in the Admin Console.

New in Google App Engine SDK 1.7.3 (Oct 24, 2012)

  • Django 1.4 is now supported in Python 2.7
  • The file-based implementation of the Datastore stub will be deprecated soon. A warning message informing users that SQLLite stub will be the default stub soon is now displayed.
  • Datastore Index stats now report type instead of representation-type.
  • Rich sort expressions beyond single field names are now supported in the Search API for dev_appserver.
  • search.MIN_NUMBER_VALUE and search.MAX_NUMBER_VALUE are now public in the Search API.
  • Globally Consistent Indexes are now deprecated in the Search API.
  • search.list_indexes() has been deprecated and replaced with search.get_indexes() in the Search API.
  • Index.list_documents() has been deprecated and replaced with Index.get_range() in the Search API.
  • Added method Index.get(doc_id) to get a document by its ID in the Search API
  • Index.add() has been deprecated and renamed to Index.put() in the Search API.
  • Index.remove() has been deprecated and renamed to Index.delete() in the Search API.
  • The AddDocumentError and RemoveDocumentError classes, which were already deprecated, have been removed from the Search API.
  • OperationCode.object_id and OperationCode.document_id, which were already deprecated, have been removed from the Search API.
  • Users can now change authentication options after app creation
  • Fixed an issue with Datastore backup/restore finalization steps only looking at the default queue in Admin Console.
  • Fixed an NDB issue with Structured Properties not converting dict properly.
  • Fixed an NDB issue where multiple async transactions corrupt old Datastore connections.
  • Fixed an NDB issue with fetch() with offset > 1000 returning an empty list.
  • Fixed an issue with 2 factor authentication not giving useful error messages.
  • Fixed an issue in the Search API snippeting breaking if the field contains a single word in dev_appserver.
  • Fixed an issue with PyCrypto AES cipher not running on dev_appserver.

New in Google App Engine SDK 1.7.2 (Sep 19, 2012)

  • Paid applications can now upload Static files and Code > 1GB. Additional storage will be billed at $0.13/GB per month. Free applications will continue to be provided 1GB of storage at no charge. Free quota will apply per application.
  • PyCrypto 2.6 is now a GA feature for Python 2.7
  • The Conversion API will be decommissioned soon. Developers using this API will receive a warning message. Please find an alternative document conversion/OCR service.
  • You can now fetch Task Queue Statistics. This allows you to fetch statistics and information about your task queue from within your application. Statistics include information such as the number of tasks in a queue, how many tasks were executed in the last minute and enforced rate. This is an experimental feature.
  • Added Timezone selection widget in Admin Console Admin Logs.
  • Added a warning message about caching when modifying or deleting datastore entities.
  • Added a flush cache button to dev_appserver and Admin Console.
  • Attempting to update multiple entity groups in a single transaction in Datastore now throws an error suggesting to use XG transactions.
  • Search API now has a string maximum length limit of 2000 characters.
  • We now allow a user with multiple google accounts the ability to create an app if they are an SMS verified user.
  • A more useful error message now displays when a deployment fails due to local date/time settings being improperly set.
  • Cron Descriptions may now include non-ASCII characters.
  • App Config Service Delete App Version Call Count quota raised to 10,000/day.
  • Queries with transactions are now supported in Remote API.
  • There are now more descriptive error messages for Datastore Admin deadline exceeded errors in stack trace.
  • Replaced error code “Administrators cannot be removed right now” with a more descriptive message.
  • Fixed an issue with namespace dropdown in Admin Console appearing blank even though the URL specified namespace is correct.
  • Fixed an issue where Model.get_by_id() returns none in dev_appserver whereas this is not allowed in production.
  • Fixed an issue with dev_appserver app_identity.get_default_version_hostname()
  • Fixed an issue with mail service sendToAdmins() failing when using multi-arg message constructor.
  • Fixed an issue with dev_appserver for mimetypes.guess_type()
  • Fixed an issue with runtime failing to use scope with OAuth under certain conditions.
  • Fixed an issue with AppConfigNotFound error.
  • Fixed an issue with static path with + in dev_appserver.
  • Fixed an issue with support for models with large numbers of properties in Admin Console Dataviewer where previously the page would fail to render.
  • Fixed an issue with multi-line string property not editing correctly in Dataviewer.
  • Fixed an issue with URLFetch mimetools.Message parsing incorrectly.
  • Fixed an issue with the behavior of Expires header in dev_appserver
  • Fixed an issue with Content-Disposition header being removed if filename contains utf-8 characters.
  • Fixed an issue with incoming Mail API where encoded headers failed to decode.
  • Fixed an issue with non-ascii text displaying incorrect values when posted by URL created by blobstore.create_upload_url()
  • Fixed an issue with using sendmail in Mail API.
  • Fixed an issue with appcfg.py cron_info giving the wrong timezone information.
  • Fixed an issue with Paging link in Datastore viewer not working with # or &
  • Fixed an issue with rounding errors in crop image transform on dev_appserver.
  • Fixed an issue with TypeError being incorrectly raised when attachment has Character Set and Language Information.
  • Fixed an issue with Mail API attachments in unicode failing in_check_attachments()
  • Fixed an issue with ereporter not reporting errors when applications use namespaces.
  • Fixed an issue with Dataviewer GQL stripping new lines after initial run and a user paginates results.
  • Fixed an issue with Python Unicode prefix in Datastore viewer.
  • Fixed an issue with get_serving_url for images giving non-cacheable URLs in dev_appserver.
  • Fixed an issue with fancy_urllib using squid proxy server with authentication.
  • Fixed an issue with custom admin page not displaying when restricted to only admins.
  • Fixed an issue with dev_appserver_import_hook.py handling Crypto import accounts.
  • Fixed an issue with Remote API gzip compression for transmitted data.
  • Fixed an issue with remote API shell not having pwd in Python Path.
  • Fixed an issue with Admin Console Logs < 30 minutes not being available.
  • Fixed an issue with Apps that are using Mail API reporting “No Provider for address type rfc822” error.
  • Fixed an issue with concurrent write access to Datastore stubs.
  • Fixed an issue with Viewers being able to prohibit code downloads.
  • Fixed an issue with billing applications that are disabled.
  • Fixed an issue with deploying to an existing version when an app has 10 versions.
  • Fixed an issue with bulkloader “model” class not uploading correctly.
  • Fixed an issue with TextProperty in Datastore viewer.
  • Fixed an issue with appcfg.py request_logs failing with ~oauth2
  • Fixed an issue with editing a bytestring field in Datastore viewer.
  • Fixed an issue with dev_appserver clearing after restart. This is a Windows only bug.
  • Fixed an issue with Cron schedule failing on 1st day of month.
  • Fixed an issue with gzip compression for application/plist content type.
  • Fixed an issue with datetime.datetime.fromtimestamp() in python 2.7

New in Google App Engine SDK 1.7.1 (Aug 22, 2012)

  • The URLFetch API now supports multiple cookie headers.
  • You can download 90 days worth of Usage Reports for your application from the Billing History page of the Admin Console.
  • Task Queue requests now include an X-AppEngine-TaskExecutionCount that counts the number of times a task was run by an instance.
  • Added support for multiple files to be deleted using the Files API.
  • Added support to delete files from Google Cloud Storage using the Files API.
  • Added a REQUEST_LOG_ID to be written in the logs and as an environment variable. This can be used to later identifying that request in the application logs.
  • The Memcache Viewer now supports namespaces.
  • The Mail API now supports the following headers for outgoing mail: List-Id, List-Unsubscribe, On-Behalf-Of, Resent-Date, Resent-From, Resent-To.
  • PyCrypto 2.6. is now supported in the Python 2.7 runtime.
  • NDB now throws a BadProjectionError when trying to perform a projection query on an unknown or unindexed property.
  • NDB Tasklets use the namespace from when it was called, not the namespace from when it is performed.
  • NDB Properties' string representation size is limited to the max string length for Blob and Text properties.
  • Appstats provides an interactive shell for observing RPC behavior of calls immediately.
  • Appstats now contains information about the cost of the RPCs made during the request.
  • The Images API now supports specifying the default pixel color to fill in for image types that don't support transparent images, such as JPEG.
  • We've added full asynchronous API support in the Images API.
  • Added an error to the Images API to indicate when a blob being referenced is not found or not accessible.
  • Made the Python search limits public in the Search API.
  • Added namespace support for the Search API in the Python SDK.
  • Added support in the Search API for simple sorting in the SDK.
  • The Testbed testing framework now supports the Logservice API.
  • Added support in the Files API to list Google Cloud Storage files.
  • Improve the MapReduce File API Reader to support multiple files and file formats.
  • Fixed an issue with the App Engine satisfaction survey in the Admin Console which was released in 1.6.6, which will be re-enabled in this release.
  • Fixed an issue with Search API websafe cursors not being returned as a websafe value.
  • Fixed an issue where SearchRequest was returning errors that weren't available as search.Error subclasses.
  • Fixed an NDB issue where entities over 1000000 bytes where written to memcache, causing failure.
  • Fixed NDB AutoBatcher error handling.
  • Fixed an issue where Appstats assuming all objects have a class attribute resulted in an error.
  • Fixed an issue where there was unbalanced string quoting in Appstats formatting.
  • Fixed an issue where search indexes were not persisted in the SDK.
  • Fixed an issue where an error in formatter.py in Appstats was being thrown.
  • Fixed an issue in the SDK where the Search API did not support boolean queries on a field.
  • Fixed an issue where numeric and date comparators were not supported in the Search API in the Python SDK.
  • Fixed an issue where Appstats didn't show a detailed view of an RPC when using the Python 2.7 runtime.
  • Fixed a search issue where snippets failed to highlight when a capital letter is used in a search term.
  • Fixed an issue where the SDK Admin tool couldn't browse search indexes containing unicode characters.
  • Fixed an issue where traffic splitting by cookie was not working.
  • Fixed an issue where RequestTooLargeError was being incorrectly thrown using Python 2.7.
  • Fixed a memcache race condition.
  • Fixed a Search issue in the SDK where a query that does not match all search terms resulted in divide-by-zero.

New in Google App Engine SDK 1.7.0 (Jun 28, 2012)

  • You can now configure your custom domain to serve HTTPS requests with App Engine. You can choose either an SNI, VIP, or SNI and VIP configuration. SNI costs $9/month for 5 certificates. A VIP costs $99/month.
  • Premier customers now have the option to create applications to be served from datacenters located in the European Union.
  • Developers can configure their HRD app to use Google's PageSpeed Service, which automatically speeds up serving of content for your application. The PageSpeed Service costs $0.39/gigabyte in addition to the normal App Engine bandwidth charges.
  • The Search API now contains support for storing and searching on GeoPoints.
  • The total size of all application versions is now limited to 1 GB. In the future, you'll be able to purchase additional storage for your application code.
  • Logs API calls are now $.12/gigabyte for all data read from the Logs API over the first 100MB.
  • You can now specify a time frame of up to 1 year for the retention of your application logs. All storage above 1 GB is billed based on the prices for logs storage.
  • You can now specify HTTP headers on static content for your application.
  • The HRD Blob Migration tool is now generally available.
  • After using the datastore backup utility, you can now restore that backup to a new app id.
  • It will not be possible to create new authorizations for M/S applications to access Cloud SQL instances.
  • You can now delete a Google Cloud Storage object using blobstore.delete().
  • You can now fetch a Google Cloud Storage object using blobstore.fetch().
  • You can now store keys for a Google Cloud Storage object in the datastore.
  • The create_upload_url call now works for Google Cloud Storage objects.
  • You can now use get_serving_url() and delete_serving_url() for Google Cloud Storage buckets.
  • Projection queries are now supported in NDB.
  • In NDB, app and namespace are now keyword arguments to get_by_id().
  • Context().call_on_commit() added to NDB for adding a callback to be executed upon successful commit of a transaction.
  • NDB Context.memcache_* ops now accept unicode.
  • NDB has added support for storing protorpc.Message objects.
  • Improved error messaging for multiple repeated=True levels with StructuredProperty in NDB.
  • PyAMF is now fully launched.
  • We've increased various Search API limits. New limits are a maximum of 1000 documents returned from search() or list_documents(), a maximum of 1000 indexes returned from list_indexes(), and a maximum offset of 1000 for search() or list_indexes()
  • Fixed an issue where the Search API did not enforce limits on NumberFields.
  • Fixed an issue in the SDK where SortExpression did not enforce the presence of a default_value set when required.
  • Fixed an issue where lxml did not support unicode parsing.
  • Fixed a javascript syntax error in the Admin Console.
  • Fixed an issue in SDK admin viewer where a TemplateDoesNotExist error was thrown when clicking on any Full-Text Search index.
  • Fixed an issue in the Search API tab of the Admin Console where it threw an error displaying non-ascii characters.

New in Google App Engine SDK 1.6.4 (Mar 28, 2012)

  • Billed applications that have specified additional logs retention over 1 GB are now being charged for that storage at $0.24/GB/month (the first gigabyte of logs storage is free). All logs beyond an application's specified storage limit will be deleted. Please examine your Application Settings page to verify you are retaining the desired amount of logs
  • Datastore statistics now show the amount of storage used by application indexes
  • We have released an experimental utility for migrating your application's blobs at the same time you migrate your datastore data. You can opt-in to blob migration in the Admin Console when you start your migration
  • We have updated the experimental Backup/Restore functionality to include the option to backup and restore to Google Cloud Storage
  • The NDB datastore API is now generally available. For full release notes on the version 0.9.9 and 1.0.0 fixes that have been integrated into the API see
  • http://code.google.com/p/appengine-ndb-experiment/source/browse/RELEASE_NOTES?name=sandbox
  • In the Python 2.7 runtime, Background threads are available as an experimental release when using App Engine backends
  • Using the Blobstore API's serve_blob() method, your application can serve objects hosted on Google Storage for Developers
  • The Admin Console now provides a Memcache viewer that lists Memcache stats and can display Memcache content based on key
  • In the Capabilities API stub in the SDK, you can now enable or disable a capability using SetPackagedEnabled
  • The Windows installer now prompts to install Python 2.7 instead of Python 2.5
  • The Testbed API now supports the Capabilities API
  • GQL queries in the Admin Console no longer throw an error when a trailing semi-colon is included
  • The Datastore API now includes a NonTransactional decorator to ensure that a function is run outside of a transaction. Existing transactions are paused while the function is executing
  • The Datastore Admin tab in the Admin Console now shows entities from every namespace
  • http://code.google.com/p/googleappengine/issues/detail?id=3962
  • Fixed an issue with _strptime when threadsafe was specified
  • http://code.google.com/p/googleappengine/issues/detail?id=6489
  • Fixed an issue where DatastoreFileStub.del fails on tempfile.msktemp
  • http://code.google.com/p/googleappengine/issues/detail?id=6749
  • WebOb 1.1.1 is now included in the SDK, and used by default there when Python 2.7 is specified
  • http://code.google.com/p/googleappengine/issues/detail?id=7014
  • Fixed an issue where the index.yaml file was cleared if your skip_files entry differs from the default skip_files list
  • http://code.google.com/p/googleappengine/issues/detail?id=7031

New in Google App Engine SDK 1.6.3 (Feb 29, 2012)

  • In the Admin Console, you can use new the Traffic Splitting feature to send a certain percentage of traffic to a non-default application version. The traffic is split by either cookie or IP address
  • Emails that are sent from Google Apps domains email addresses where the domain has been set up to use DKIM will be signed: when an email was from a request that originated on that app's domain or any time the email was sent from an app adminstrator, including when that email is sent from a cron job or task queue request
  • In the Admin Console, you can now choose how much and how long you'd like to store logs. All apps get 1G for free and eventually will be able to pay for more, while the amount can be increased this release we won't start charging for the additional capacity until the next release at the earliest
  • The instances screen in the Admin Console now has a button to shut down a specific instance
  • Each application log has a link to the instance that served the request. If the instance is no longer serving requests, a message will be displayed
  • The TaskQueue API now supports the ability to tag a Pull Queue task. You may then lease tasks by tag. This feature is experimental
  • Using Google Apps wildcard domain mappings, you can access alternate versions of your app via a custom domain
  • Push and Pull Queues are now listed separately in the SDK development console
  • Developer documentation for the experimental NDB API, the replacement for db.py, is now available
  • appcfg.py now supports OAuth2
  • webapp 2.5.1 is now available in the Python 2.7 runtime
  • Django 1.3 is now available in the Python 2.7 runtime
  • GQL Query now supports custom type casting for list elements for IN filters
  • Fixed an issue where StringProperty's validate() didn't check the 500 byte limit
  • http://code.google.com/p/googleappengine/issues/detail?id=4030
  • Fixed an issue where the datastore admin didn't work with Federated Login
  • http://code.google.com/p/googleappengine/issues/detail?id=4111
  • Fixed an issue in the SDK where failing to call _RemoveTxn in the datastore_stub_util caused a memory leak
  • http://code.google.com/p/googleappengine/issues/detail?id=6157
  • Code that inherits from the deferred library's TaskHandler can now define custom handling of exceptions
  • http://code.google.com/p/googleappengine/issues/detail?id=6478
  • Fixed an issue where logging in the SDK was broken in Windows 7 using Python 2.7.2
  • http://code.google.com/p/googleappengine/issues/detail?id=6756
  • Fixed an issue in the SDK where the Conversion API call limited was limited to 1MB when the production limit is 2MB
  • http://code.google.com/p/googleappengine/issues/detail?id=6794
  • Fixed an issue so that a deferred task retries like a push queue task when using the SingularTaskFailure exception
  • http://code.google.com/p/googleappengine/issues/detail?id=6412

New in Google App Engine SDK 1.6.2 (Feb 8, 2012)

  • The Admin Console Datastore Admin has added experimental backup and restore functionality. The job occurs within your application and counts against your application quota, including Instance Hours, Datastore Ops and Datastore Storage
  • Developers can now specify how long a channel token will last until it expires, with the default remaining two hours. Channel API quota is now measured both in calls to create a channel and the number of hours of channel time requested. The maximum hours of quota is the maximum number of channel creation calls * 2, so free apps get 200 hours of requested channel token time
  • Python Django now work with Cloud SQL without additional configuration. For further information see https://developers.google.com/cloud-sql/
  • Task Queue API requests now include a X-Appengine-TaskETA header, that can be used to measure task delivery latency
  • The default API deadlines for Blobstore API calls have been raised to 15s for online and 30s for offline requests, up from 5s
  • The Images API now allows you to stretch an image without maintaining the aspect ratio
  • http://code.google.com/p/googleappengine/issues/detail?id=2220
  • The Blobstore API now includes the asynchronous function calls create_upload_url_async, delete_async, and fetch_data_async
  • Django version 1.3 is now available in the Python 2.5 runtime
  • We've added a django_wsgi builtin to allow easier bootstrapping of Django applications
  • Mail Quota for App Engine apps that have signed up for billing will only be increased after the first payment for the app is processed
  • As announced in 1.6.1, in this release for the experimental Python 2.7 runtime, the mapreduce and datastore_admin builtins are not available to apps deployed to Python 2.7
  • Fixed an issue with remote_api where calling fetch_page() with a page size of 301 and chaining the calls through the returned cursor was skipping half of the results
  • Fixed an issue where the PIL _imagingmath module was not available in Python 2.7
  • Fixed an issue where the dev_appserver did not resize images down to 512 pixels by default, as it does in production
  • Fixed an issue with the Images API where valid images were returning a NotImageError
  • http://code.google.com/p/googleappengine/issues/detail?id=5545
  • Fixed an issue where the dev_appserver didn't start when using Python 2.7 and the --backends flag
  • http://code.google.com/p/googleappengine/issues/detail?id=6187
  • Fixed an issue where Jinja2 was not included in the SDK for use with Python 2.7
  • http://code.google.com/p/googleappengine/issues/detail?id=6265
  • Fixed an issue with the sql datastore stub in Python 2.7 where the sqlite module no longer accepted strings with non-ASCII characters
  • http://code.google.com/p/googleappengine/issues/detail?id=6290
  • Fixed an issue where gzip did not work with Python 2.7 in the dev_appserver
  • http://code.google.com/p/googleappengine/issues/detail?id=6324
  • Fixed an issue where urllib2 did not work with Python 2.7
  • http://code.google.com/p/googleappengine/issues/detail?id=6567
  • Fixed an error in the Datastore Viewer where an error was thrown when viewing an Entity which defines an index with no properties
  • http://code.google.com/p/googleappengine/issues/detail?id=6600
  • Fixed an issue where transactional tasks were not enqueued in the dev_appserver when running in --high_replication mode
  • http://code.google.com/p/googleappengine/issues/detail?id=6669

New in Google App Engine SDK 1.6.1 (Feb 8, 2012)

  • You can now configure Frontend Instance Classes from your Admin Console's application settings page. Three classes are available, with increasing memory, CPU limits, and associated cost. By default, all applications use the basic frontend instance setting of 128MB memory and 600MHz CPU
  • We've added new functionality to the Log API that will allow you to read your application's logs programmatically
  • We are releasing an experimental Conversion API that will allow you to convert between document types including .doc, .html, .pdf, images using OCR, and more
  • The High Replication Datastore migration utility is now available as a GA feature, and is no longer experimental
  • The ext.db API query functions (run, fetch, count, get) now accept the keyword arguments: deadline, read_policy, prefetch_size, batch_size, limit, offset, start_cursor, end_cursor, keys_only. It is recommended that developers use Query.run() with a limit or batch_size instead of Query.fetch() when iterating over results
  • The ext.db API model functions (get, put, delete, allocate_ids) now directly accept the keyword arguments: deadline, read_policy
  • The Blobstore API now supports the multiple="true" attribute to the HTML input tag
  • Fixed an issue logging unicode objects in the SDK
  • Fixed an issue with the dev_appserver where HTTP HEAD always returned content-length: 0
  • http://code.google.com/p/googleappengine/issues/detail?id=2000
  • Fixed an issue in the SDK where importing Crypto.Util.Counter caused an ImportError
  • http://code.google.com/p/googleappengine/issues/detail?id=4168
  • Fixed an issue where the SDK didn't work with virtualenv
  • http://code.google.com/p/googleappengine/issues/detail?id=4339
  • Fixed an issue where cached static files served to IPs on the DoS blacklist consumed bandwidth quota
  • http://code.google.com/p/googleappengine/issues/detail?id=4607
  • Fixed an issue that was causing slow serving of requests in the SDK
  • http://code.google.com/p/googleappengine/issues/detail?id=6005
  • Fixed an issue where the Channel API didn't work in the SDK with Python 2.7
  • http://code.google.com/p/googleappengine/issues/detail?id=6267
  • Fixed an httplib compatibility issue between Python 2.5 and Python 2.7 in the SDK
  • http://code.google.com/p/googleappengine/issues/detail?id=6271
  • Fixed an issue where queries larger than 1MB didn't work with Python 2.7
  • http://code.google.com/p/googleappengine/issues/detail?id=6282
  • Fixed an error in the SDK on first page load for a handler
  • http://code.google.com/p/googleappengine/issues/detail?id=6302
  • Fixed an issue in the SDK that caused slowness due to app's logs being written to the datastore. Set the --persist_logs flag in the SDK if you are using the Logservice API to read logs
  • http://code.google.com/p/googleappengine/issues/detail?id=6355
  • WARNING: Starting with the 1.6.2 release of the experimental Python 2.7 runtime, the mapreduce and datastore_admin builtins will not be supported

New in Google App Engine SDK 1.6.0 (Feb 8, 2012)

  • On November 7th, App Engine will be out of Preview. The new Terms of Service and previously announced pricing changes will be in effect. Additionally, all paid apps are now covered by our SLA
  • http://code.google.com/appengine/docs/billing.html
  • Paid apps can now specify the maximum pending latency for instances and the minimum number of idle instances for your application in the Admin Console
  • Task Queue storage has been separated in to its own line item. Previously, this was included in Datastore storage
  • We have released an experimental utility, available in the Admin Console, to assist in migrating your application to the High Replication datastore. This utility allows you to copy the bulk of your data in the background, while the source application is still serving. You then need a brief read-only period to migrate your application data while you copy the data that has changed from the time the original copy started
  • Blobstore, which was previously limited to apps with billing enabled, is now available for all apps
  • We have published a new article on Datastore Index Selection and Advanced Search which explains our recent improvements to the query planner that make exploding indexes unnecessary
  • http://code.google.com/appengine/articles/indexselection.html
  • Applications can now receive XMPP error stanzas at /_ah/xmpp/error
  • In the Admin Console data viewer, you can now filter by namespace from a drop down menu, if applicable
  • In the Admin Console's Datastore Statistics, we now offer namespace suggest for filtering stats
  • We have released as experimental the full MapReduce framework
  • The SDK now supports Python 2.7
  • Python 2.7 now supports WebOb 1.1.1, which has some significant bug fixes. Applications that explicitly set the "webob" version to "1.1" in their app.yaml files must update the version to "1.1.1"
  • The mail_stub.get_sent_messages() call now returns EmailMessage instances
  • Fixed an issue when setting an initial_value in memcache.incr unexpectedly returned a string
  • http://code.google.com/p/googleappengine/issues/detail?id=2012
  • Fixed an issue where DoS stats in the Admin Console didn't work for High Replication apps
  • http://code.google.com/p/googleappengine/issues/detail?id=5237
  • WARNING: Starting with 1.6.1 (our next release, NOT this release), URLFetch requests will honor the Accept-Encoding header. If your code sets this header, then it must be prepared to receive content of the specified type. For more information please see
  • http://code.google.com/p/googleappengine/issues/detail?id=4978

New in Google App Engine SDK 1.5.5 (Feb 8, 2012)

  • Python 2.7 is now available as an experimental runtime for all applications using the High Replication Datastore. To upload your app to the Python 2.7 runtime, change the runtime argument in your app.yaml to python27. Note that the dev_appserver does NOT work with Python 2.7 - you must deploy your application in order test it
  • We have increased the number of files you can upload with your application from 3,000 to 10,000
  • We have increased the size limit for a single file uploaded to App Engine from 10MB to 32MB
  • We have increased the Frontend request deadline from 30 seconds to 60 seconds
  • We have increased the online URLFetch maximum deadline from 10 seconds to 60 seconds. The default deadline remains at 10 seconds. The offline maximum deadline for URLFetch remains at 10 minutes
  • We have increased the URLFetch Post payload from 1MB to 5MB
  • App Engine now supports Cross Group (XG) transactions with the High Replication Datastore, which allow you to perform transactions across multiple entity groups. http://code.google.com/appengine/docs/python/datastore/transactions.html
  • We have released an experimental API that can write to Google Storage for Developers directly from App Engine. http://code.google.com/appengine/docs/python/googlestorage/overview.html
  • We have added a graph to the admin console that displays the number of instances for which you will be billed
  • In the XMPP API, get_presence() is deprecated in favor of using the inbound presence handlers documented in http://code.google.com/appengine/docs/python/xmpp/overview.html#Handling_User_Presence
  • The Task Queue API 'target' parameter now accepts a new value, taskqueue.DEFAULT_APP_VERSION, which will send the task to the default frontend version, rather than the version or backend where the 'add' method is being called
  • In the URLFetch API, make_fetch_call() now returns an RPC object
  • Fixed an issue in the Admin Console where the "Run Now" button did not work for tasks with a '-' in the name
  • Fixed an issue where the SDK did not decode Base64 encoded blobs
  • Fixed an issue to provide a better error message when using the Mail API to send email to an invalid user address
  • Fixed an issue in the SDK where a skip_files entry caused an ImportError when the library was located elsewhere in the PYTHONPATH
  • Fixed an issue in the SDK index viewer where the arrows indicating whether a query was ascending or descending were not properly rendered
  • Fixed an issue where httplib did not support the deadline argument for URLFetch calls. http://code.google.com/p/googleappengine/issues/detail?id=2216
  • Fixed an issue where you could not schedule a cron job to run every 100 minutes. http://code.google.com/p/googleappengine/issues/detail?id=5243
  • Fixed an issue in the SDK where failed tasks retried immediately instead of waiting for 30 seconds. http://code.google.com/p/googleappengine/issues/detail?id=5587
  • Fixed an issue making it possible to modify request headers using the deferred library. http://code.google.com/p/googleappengine/issues/detail?id=5861

New in Google App Engine SDK 1.5.4 (Feb 8, 2012)

  • You can now specify the maximum size for a blob in create_upload_url()
  • Zigzag merge join queries will now continue scanning up to the 30 second Datastore query deadline. For zigzag queries that used to generate NeedIndex errors, many will now succeed. A small percentage will now instead timeout
  • The SDK datastore viewer in the dev console now displays the number of "Write Ops" for each entity. "Write Ops" are the total number of entity and index writes that were required to create the entity
  • Added API functionality for making calls to the Memcache API asynchronously
  • Fixed an issue that incorrectly allowed creation of tasks with whitespace in the url
  • Fixed the error message for "transaction not found" to be more descriptive
  • Fixed an issue where blobstore uploads didn't work in the SDK with the -a 0.0.0.0 flag set
  • Fixed an issue where --dry_run was broken for upload_data in bulkload.py
  • Fixed an issue where db.Model().to_xml() incorrectly updated auto-updating properties
  • http://code.google.com/p/googleappengine/issues/detail?id=322
  • Fixed an issue where the SDK didn't expand the '~' in a file path
  • http://code.google.com/p/googleappengine/issues/detail?id=522
  • Fixed an issue where is_saved() wasn't valid after db.Model.init
  • http://code.google.com/p/googleappengine/issues/detail?id=844
  • Fixed an issue where GQL IN queries with an empty list returned all entities
  • http://code.google.com/p/googleappengine/issues/detail?id=932
  • Fixed an issue where the SDK's sqlite stub did not handle cursors on descending queries correctly
  • http://code.google.com/p/googleappengine/issues/detail?id=3121
  • Fixed a typo in the SDK's Datastore Stats generator message
  • http://code.google.com/p/googleappengine/issues/detail?id=5425

New in Google App Engine SDK 1.5.3 (Feb 8, 2012)

  • We've removed the limit on the size of blob uploads using the Blobstore API
  • You can now send emails with any attachment extension that is not included on the email attachment extension blacklist
  • Added a db.get_indexes() method to retrieve an application's indexes and their corresponding states
  • The dev_appserver has been updated to understand the reduced index requirements, thanks to the 1.5.2 datastore query planner changes
  • The Datastore Admin functionality can now be enabled directly in the Admin Console
  • Added cas(), the compare-and-set function, to the Memcache API
  • http://code.google.com/p/googleappengine/issues/detail?id=2139
  • Added a set_default_fetch_deadline to the URLFetch API which sets the URLFetch deadline globally
  • Added app_identity api with methods to get the application id, default hostname, and service accounts for asserting identity on outbound HTTP calls
  • http://code.google.com/appengine/docs/python/appidentity/overview.html
  • Added an improved HRD migration tool that requires a read-only period relative to your datastore write rate (as opposed to your datastore size, which is how the current version behaves). The tool is not yet generally available. If you are interested in being an early adopter please fill out this form
  • http://goo.gl/3jrXu
  • Fixed an issue in the Channel API where jsapi was not served with the correct MIME type
  • Fixed an issue that broke use_library when the Python SDK was located in a directory that contained the word django
  • Fixed an issue where blobs could not be uploaded using HTTPS
  • Fixed an issue where GQL didn't allow querying for valid kind names containing '.', '-', and ':' by supporting quoted identifiers

New in Google App Engine SDK 1.5.2 (Aug 3, 2011)

  • You can now specify the minimum pending latency for instances and the maximum number of idle instances for your application in the Admin Console.
  • The datastore now never requires an exploding index.
  • The SDK will now never suggest indexes with the same property repeated, as such indexes are likely to be exploding indexes.
  • The SDK now supports multiple concurrent transactions.
  • Datastore stats are now available on a per-namespace basis.
  • The queue details page in the Admin Console now contains request header details, previous run information, and a task payload viewer.
  • You can modify the lease on a task leased from a pull queue using the modify_task_lease() method.
  • Pull Task maximum size has been increased to 1MB.
  • You can now update the number of available backend instances without needing to first stop the backend using the "backend configure" appcfg.py directive.
  • You can now set the "References" and "In-Reply-To" headers with the Mail API.
  • The SDK "application" environment variable will now be prefixed with dev~. The new preferred way of retrieving your app id is to use appidentity.get_application_id(). The --default_partition flag can be used for applications whose code relied on a specific environment variable.
  • In the Deferred API, defer() now accepts the _target parameter.
  • Added a to_dict() function to db.py which converts a model to a dictionary.
  • Added a get_original_metadata() method to the Images API to extract EXIF information from images.
  • Added an @transactional decorator to db.py for functions that should always be run in a transaction.
  • Fixed an issue in the SDK where the Deferred API did not work when using the --backends flag.

New in Google App Engine SDK 1.5.1 (Aug 3, 2011)

  • ProtoRPC is a new experimental library that provides a simple method for creating a well-defined and easy-to-use web-based RPC service.
  • The development server's datastore implementation now contains logic that closely replicates the consistency guarantees of the High Replication datastore. To use, run the dev_appserver with the flag --high_replication set to True.
  • All user request have an X-AppEngine-Country header which contains the ISO-3166-1 alpha-2 country code for the user, based on the IP address of the client request.
  • Applications are now associated with an app_identity, which can be used to authenticate requests originating from the app to other services.
  • The Channel API can now provide user presence, this can be configured by adding channel_presence to the list of inbound services for your application.
  • The Images API now supports the WebP format. Due to limitations in PIL, the SDK does not support the WebP format.
  • You can switch the timezone for App Engine logs in the Admin Console.
  • Fixed an issue in the SDK where leased tasks had the POST method. They now have a PULL method.
  • Fixed an issue where the Channel API didn't work with non-default versions of applications using the High Replication datastore.
  • When displaying corrupt data in the Admin Console dataviewer, a useful error will be displayed, instead of a 500.

New in Google App Engine SDK 1.5.0 (Aug 3, 2011)

  • Support for Backends which allow developers to create infrastructure components that complement the existing dynamic apps that App Engine already provides. Instances of a backend can maintain state, be addressed individually, and are not subject to per-request time limits. They can also be configured to consume more memory and CPU than ordinary dynamic instances.
  • Task Queues support pull mode, allowing for more control over task queue work rates. To use pull queues, include the 'mode' argument in your queue.yaml.
  • Pull queues are supported by a REST API, allowing access from outside App Engine. To use the REST API, you must also include a valid ACL section specifying which users can lease tasks from the pull queue.
  • Task Queue payload limits have been increased. Queues support 100KB per task. Within App Engine, the new limit is 32 MB per batch of tasks. With the REST API the limit is 1 MB per batch.
  • HTTP request and response sizes have been increased to 32 MB.
  • We have removed the rate quotas for requests, datastore operations, memcache operations, and image API operations. Resource quotas still apply.
  • When creating new applications, developers will now see the High Replication Datastore as the default configuration option. Developers that still wish to use the Master/Slave configuration must explicitly choose this option at application creation time.
  • The Task Queue maximum configurable processing rate has been increased to 500/s.
  • We have added two restrictions to the Mail API to improve the reliability of the service for all application.
  • Emails must be sent from email accounts managed by Google (either Gmail or a domain signed up for Google Apps).
  • Reduced the number of free recipients per day from 2000 to 100 for new applications.
  • All application Owners, as listed in the Admin Console, can download the app's code, unless code download is disabled for the application.
  • Added db.py support for making calls to the datastore asynchronously. Available functions are get_async(), put_async(), delete_async(), allocate_ids_async(). Call get_result on the return value of asynchronous datastore functions to block on the call.
  • Metadata queries can now get all namespaces, kinds, and properties in a given range.
  • The Testbed API now supports the Channel API.
  • Users can provide Django settings to be loaded in webapp's django_setup.
  • Modified Dashboard latency graphs to indicate they only include dynamic requests.
  • Fixed an issue where metadata queries did not support unicode characters.
  • Fixed an issue where HTTP headers could contain new line characters.
  • A warning message is shown when the Python version used to run the SDK is different than the Python version used in production.
  • Fixed an issue with Federated Users causing the Admin Console dataviewer to fail.
  • MacOS and Windows style newlines are now supported for logging in the SDK.
  • Fixed an issue where sending mail with smtp_host set did not work.
  • Fixed the file permissions for appinfo_errors.py and appinfo.py in the SDK.
  • Fixed an issue deploying an app with version set to 0.
  • Fixed an issue where the SDK allowed GET or DELETE with a body, which does not work in production.
  • Fixed an issue where URLFetch/urllib did not work with MacOS and Python 2.6.0-2.6.3.
  • Fixed the an issue in the SDK where the mail body was incorrectly generated when the sendmail option was enabled.
  • Fixed an issue in the SDK dataviewer where editing a ListProperty(db.Category) resulted in a BadValueError.
  • Fixed an issue in the SDK where the signal module could be imported, as it is not supported.
  • Improved support for reserving an app id that is a canonicalized version of a user's Gmail address.
  • Added a more useful error messages for unavailable App Ids.
  • The SDK now uses hashlib instead of sha. Python 2.4 is no longer supported.
  • Fixed an issue where images.composite() did not support PNG transparency in the SDK.
  • Added better error messages for cron.yaml parsing.
  • Fixed an issue where uploading an index.yaml file with DOS line endings caused an error.
  • Fixed an issue where unicode characters in a script caused an error.
  • Task Queue names can now include the "" character.
  • The sender of an email is no longer BCC'd when they are already included in the email.
  • Fixed an issue where non-string types were interpreted as strings when parsing the index.yaml file.
  • Image API now supplies image format.
  • Fixed webapp.request.get_range to work with default=None.
  • Added a more helpful error message when trying to send email to a malformed address.
  • The SDK now returns an error if the Content-length header is not included in a post request, matching production.
  • Fixed an issue using URLFetch to fetch pages where the URL contained unicode.
  • Fixed an issue where the SDK looked in the wrong folder for the SDK Version file.
  • Fixed a webapp.Request get() issue where the default was not being properly returned when allow_multiple was set to True.
  • Fixed an issue where handler.get_url did not work for non-default versions of Django.
  • Fixed an issue where X-AppEngine-TaskRetryCount did not increment in the SDK.
  • Applied a user patch that partially fixed an issue where bulkloader resume was not working.
  • Fixed a logging issue with the SDK BlobImageDispatcher.
  • ListProperty now supports datetime.time and datetime.date, as documented.
  • Fixed an issue where the Content-length header was being incorrectly stored as an integer.
  • Fixed an issue where the Admin Console didn't keep the app version viewed consistent across actions.
  • Fixed an issue using os.environ in appengine_config.py in the SDK.
  • Fixed an issue where HTTP requests on the SDK where truncated if a semicolon was included in the request.
  • Fixed an issue where images.get_serving_url() did not handle blob_info.key() correctly.
  • Fixed an issue where checking for a new version caused the appcfg download_app command to fail.
  • Fixed a typo in the Admin Console on the New App page.
  • Return a better error when a ReferenceProperty fails to resolve.
  • Fixed an issue where sending mail from an app registered on the HR datastore required the app id be prefaced with s~.
  • Fixed an issue where URLFetch with urllib over HTTPS didn't work.

New in Google App Engine SDK 1.4.3 (Apr 4, 2011)

  • Added Files API that allows writing to and reading from files in blobstore.
  • You can now specify cron execution for a time interval between a start and end time.
  • You can now configure the specific application version to which a task queue or cron job will send requests.
  • The Admin Console Task Queues page now displays a more accurate estimate of queue size for queues containing more than 2000 tasks.
  • The Prospective Search API (formerly named the Matcher API) is available for use by all applications. This API is still experimental, so applications will be limited to a maximum of 1000 subscriptions.
  • The Testbed API provides easy configuration of stub libraries for local integration tests.
  • In the Images API, the quality parameter was added to the resize, rotate, horizontal_flip, vertical_flip, crop and im_feeling_lucky methods.
  • Fixed an issue where static file serving in the dev_appserver didn't support etags.
  • An error is now raised when the script mapping in the app.yaml file is missing the .py file extension.
  • Fixed an issue where no link was displayed in the Admin Console blobstore viewer for an unnamed blob.
  • Fixed an issue where the Admin Console data viewer couldn't edit entities with ByteString properties.
  • Fixed an issue where the Admin Console crashed when using a non-ascii key_name.
  • Fixed an issue filtering on key while using the --use_sqlite option with the dev_appserver.
  • The Disable Application admin function has been button-ized.
  • Fixed an SDK issue where debugging logging wouldn't correctly print URLFetch payloads.
  • Fixed an SDK issue where an incompatible line ending was used on blob upload.
  • Added more graceful handling of the missing mapreduce.yaml file when the user has enabled the Datastore Admin but is not otherwise using the MapReduce framework.
  • Fixed an issue where the method webapp_add_wsgi_middleware was no longer recognized.

New in Google App Engine SDK 1.3.8 (Oct 17, 2010)

  • Builtin app.yaml handlers are available for common application functions, such as appstats.
  • http://code.google.com/appengine/docs/python/config/appconfig.html#Builtin_Handlers
  • The Admin Console now provides an experimental tool to delete all entities in the datastore or all entities of a given type. This is available only if enabled using the datastore_admin builtin. Deleting entities will count against application quota.
  • http://code.google.com/appengine/docs/python/datastore/creatinggettinganddeletingdata.html#Deleting_Entities_in_Bulk
  • You can run task queue tasks immediately from the Admin Console.
  • You can now specify the quality of JPEG images via the Image API's execute_transforms function. Available in production only.
  • Support for login of multiple Google accounts within an app, and longer login sessions. For more information see:
  • http://www.google.com/support/accounts/bin/answer.py?answer=181599
  • In queue.yaml, the maximum allowed bucket size is now 100.
  • Precompilation is now enabled by default. To disable, use the --no_precompilation flag when updating your app.
  • BlobInfo now has an open() method that returns a BlobReader.
  • BlobReader now accepts a BlobInfo.
  • Removed limits on zigzag merge-join queries. Therefore the error "The built-in indices are not efficient enough for this query and your data. Please add a composite index for this query." will no longer be thrown in most cases, enabling more types of queries without indexes.
  • Fixed an issue with task queue tasks not running on the dev_appserver when using Python 2.6.
  • Fixed an issue on the dev_appserver where auto task running wasn't working for BulkAdd.
  • Fixed an issue reserving App Ids by owners of similarly-named mails accounts containing periods, multiple cases, and googlemail.com address.
  • http://code.google.com/p/googleappengine/issues/detail?id=1196
  • Fixed an issue on the development server where PNGs were being returned as JPEGs.
  • http://code.google.com/p/googleappengine/issues/detail?id=3661

New in Google App Engine SDK 1.3.7 (Sep 1, 2010)

  • Fix an issue where namespace_manager.google_apps_namespace() was not included in the 1.3.6 release.

New in Google App Engine SDK 1.3.6 (Sep 1, 2010)

  • Multitenancy is now supported in the datastore, allowing better compartmentalization of user data.
  • Automatic image thumbnailing is now available in the Images API using get_serving_url().
  • Users can now serve custom static error pages for over_quota, dos_api_denial and default cases.
  • Results of datastore count() queries and offsets for all datastore queries are no longer capped at 1000.
  • Added a pause queue button to the task queue details page in the Admin Console.
  • Historical graphs have been added to all of the dashboard graphs in the Admin Console.
  • Content-range headers are supported on Blobstore downloads.
  • Remote API now supports the Blobstore API.
  • New method to allocate datastore ids in a given range: db.allocate_id_range().
  • New db method is_in_transaction() determines if a transaction is still open.
  • Increased several rate limited quotas for free applications.
  • Fixed an issue in db.py where unindexed property lists for user-specified property names were ignored.
  • Fixed an issue where the task queue uses local time instead of UTC time to compute job ETA.
  • Fixed an issue in the SDK with datastore cursors being too large.

New in Google App Engine SDK 1.3.5 (Sep 1, 2010)

  • Developers can enable Python pre-compilation to decrease start up time for new application instances. This can be enabled by including the derived_file_type in your app.yaml.
  • Ability to configure the Task Queue storage limit with the total_storage_limit field in the queue.yaml file.
  • Task Queues now support up to 50 qps per queue, up from 50 qps per app.
  • Developers can programmatically access Blobs with BlobReader, a file-like interface for reading blobs.
  • Bulkloader transform helpers for lists and hierarchical keys were added.
  • remote_api_shell commands can be sent over HTTPS or HTTP.
  • Admin Console logs now include information on request time latency.
  • Db.delete will now accept an iterable, in addition to a list of models or keys.
  • The datastore now supports end cursors.
  • Fixed an issue properly handling a query with an offset that returns no results.
  • Fixed an issue that improperly allowed quad-dotted netmasks as subnet prefixes for the DoS API.
  • Fixed an issue via user submitted patch in the SDK dataviewer displaying multiline StringProperties.

New in Google App Engine SDK 1.3.4 (May 20, 2010)

  • New bulkloader configuration syntax and wizard for easier import/export with the datastore.
  • Applications can now be configured to authenticate with OpenID by selecting the OpenID option when creating your application in the admin console.
  • New API to allow App Engine apps to act as OAuth service providers.
  • Auto task execution is now enabled in the dev_appserver. To turn this off use the flag --disable_task_running.
  • Fixed an issue using db.put() with constructor initialized id based keys.

New in Google App Engine SDK 1.3.3 (May 20, 2010)

  • new experimental feature allows you to set dev_appserver datastore file stub to use sqlite. To enable, set the flag --use_sqlite=true.
  • It is now possible to implement properties on db.Expando.
  • Fixed a datastore issue where an error was thrown when setting a query offset to more than the number of results throws an error.
  • Fixed issue not allowing ByteString type to be viewed in the Development Console datastore viewer

New in Google App Engine SDK 1.3.2 (Mar 26, 2010)

  • New API to read the contents of uploaded Blobs (fetch_data)
  • URLFetch now supports accessing ports 80-90, 440-450, and 1024-65535
  • Mail API now allows common document formats as attachments
  • The Task Queue API now supports adding multiple tasks in a single call to Queue.add()
  • Fixed charset handling for inbound emails
  • Fixed issue with compositing background colors in dev_appserver
  • New feature in the datastore to specify whether to use strong or eventually consistent reads (the default is strong)
  • New datastore feature allows setting deadlines for operations
  • Increased the maximum Task Queue refill rate from 20/s to 50/s
  • Support for IP blacklisting to prevent denial of service (DoS) attacks
  • Fix issue with slow updates when there are many skipped files
  • Fix issue with cursor not updating when using a GqlQuery

New in Google App Engine SDK 1.3.1 (Feb 11, 2010)

  • Datastore Query Cursors
  • Transactional Task Creation
  • Support for Custom Admin Console pages
  • New "month" and "synchronized" syntax for Cron configuration
  • Application Stats library now included in with SDK
  • Bulk Loader supports bulk downloading all kinds simultaneously
  • appcfg.py validates SSL certificates for HTTPS on Upload
  • Support for ETags, If-matches, If-not-matches HTTP Headers, as well as 304 status codes now available on static files (not available on the dev_appserver or Blobstore blobs)

New in Google App Engine SDK 1.3.0 (Dec 15, 2009)

  • Adds support for the new Blobstore API
  • Service Changes:
  • Added new Blobstore Viewer to Admin Console

New in Google App Engine SDK 1.2.8 (Dec 4, 2009)

  • New memcache offset_multi method and batch support in incr and decr.
  • Urlfetch Response object now contains final_url of 302 redirects.
  • Additional file extensions permitted when sending mail.
  • Fixed issue decoding messages for incoming mail.
  • Fixed issue with datastore list properties containing both blob (or text) and non-blob values.
  • Fixed Users API usage with remote_api
  • Fixed issue with IN queries in remote_api
  • Bulk Loader --dump and --restore now work across app IDs.
  • Bulk Loader --restore works with numeric IDs.
  • Bulk Loader exporter maps key property to the entity key.
  • Fixed issue in Bulk Loader with missing properties on export.
  • Fixed issue in Bulk Loader with line breaks in data.
  • Fixed exception in Bulk Loader with certain data ranges.
  • Added SERVER_SOFTWARE environment variable to runtime.
  • New "auth_fail_action: unauthorized" option in app.yaml: when present, a 401 status code will be returned instead of a 302 redirect to the Google Accounts login page for pages with login: required.
  • Service Changes:
  • New Index building status page in the Admin Console
  • Task Queue now supports purging queues, and deleting tasks and queues via the Admin Console.
  • Over Quota HTTP status code changed from 403 to 503, other to 500.
  • Task Queue now considers all HTTP 2xx status codes to represent success.

New in Google App Engine SDK 1.2.7 (Oct 16, 2009)

  • Changed the 'key' parameter to Model.init to be keyword only.
  • Fixed taskqueue import in Remote API.

New in Google App Engine SDK 1.2.6 (Oct 14, 2009)

  • Added incoming email support.
  • Remote API now supports XMPP and task queues.
  • The default for all handlers is now secure: optional. Users can now access all pages via SSL unless explicitly disallowed.
  • Remote API now supports HTTPS.
  • Appcfg now uses https by default.
  • Appcfg.py now supports the --application and --version flags to override the values specified in app.yaml.
  • GQL now supports '= NULL' queries.
  • The db.Model constructor now supports explicitly setting a key (and thus an id) for a Model instance.
  • New Datastore stats api. Stats are also visible in the admin console.
  • Bulkloader dump and restore now supports restoring to a different app id and restoring numeric keys.

New in Google App Engine SDK 1.2.5 (Sep 4, 2009)

  • The Windows Python SDK now includes a GUI launcher, similar to the Mac SDK.
  • Added XMPP support.
  • Datastore now supports multiple writes to the same entity within a transaction.
  • Datastore entity key names can now start with a digit.
  • Datastore now supports ancestor + kind queries without a composite index
  • Bulkloader now supports configurationless dump and restore with new --dump and --restore options.
  • Bulkloader now supports a --dry_run flag to testing data prior to uploading.
  • Appcfg.py now allows specifying any end date for request_logs.
  • Urlfetch now allows setting the Referer header.
  • Urlfetch stub now correctly handles HEAD requests.
  • New remote_api_shell tool for interactive remote_api operations.
  • New google.ext.ereporter module to collect and email exception reports.
  • New google.ext.deferred module to execute ad-hoc tasks on the Task Queue.

New in Google App Engine SDK 1.2.3 (Jun 19, 2009)

  • Task Queue support available as google.appengine.api.labs.taskqueue.
  • Django 1.0 support. You must install Django locally on your machine for the SDK but no longer need to upload it to App Engine.
  • Urlfetch supports asynchronous requests.
  • Urlfetch in SDK now matches App Engine more closely: By default, it now sets the referer header, does not set the Accept header, and sets Accept-Encoding to gzip.
  • Fixed issue with httplib and absolute URLs.
  • Memcache key length is no longer restricted to 250 bytes: longer keys will be replaced with a hash of the key.
  • Datastore ancestor queries now work within transactions.
  • Datastore transactions in SDK now snapshot on the first operation so they do not see writes made during the transaction. Matches App Engine.