------------------------------------------------------------------------        

December 5, 2021
  Version 2.0.4 released.
  * backwards incompatible changes:
    * All service name and service name patterns must be UTF-8
    * The ATS CloudI API subscribe function now uses the
      implement template idiom to simplify use
  * Improved the C/C++ CloudI API backtrace information
  * Added the cloudi_service_send service for simpler automation
  * Fixed the service configuration options
    aspects_suspend and aspects_resume
  * OCaml 4.13 support was added
  * Bugs were fixed and other improvements were added
    (see the ChangeLog for more detail)

May 27, 2021
  Version 2.0.2 released.
  * Added the ATS CloudI API (ATS2/Postiats >= 0.3.13)
  * Added more information to the CloudI Service API functions
    services_status, nodes_status, logging_status and code_status
  * Added the overload queue_mode to the CloudI logger to prevent
    node logging redirects from causing excessive memory consumption
  * Updated cloudi_service_http_cowboy to use cowboy 2.9.0
  * Added cache replacement algorithms to cloudi_service_filesystem
    (replace argument may be lfuda, lfuda_gdsf or lru)
  * Added queue dependencies to cloudi_service_api_batch
  * Added more descriptive C/C++ CloudI API termination handler output
  * Erlang/OTP 24 support was added
  * Added hackney support to cloudi_service_http_client
  * Added the service configuration options aspects_suspend and
    aspects_resume for handling service suspend state changes
  * Bugs were fixed and other improvements were added
    (see the ChangeLog for more detail)

November 27, 2020
  Version 2.0.1 released.
  * backwards incompatible changes:
    * CloudI API external service request exception handling will now
      cause a service restart for unrecoverable exceptions and
      assertions (e.g., Error in Java)
    * CloudI Service API code_path_add, code_path_remove and
      code_path uses separate storage of paths (separate from Erlang)
  * FatalError exception added to external service CloudI APIs
    to cause a service restart for unrecoverable service errors
  * Added the CloudI Service API functions logging_status and
    logging_status_reset for tracking file output details
  * 'code' configuration file section was added to simplify the
    loading of Erlang source code
  * cloudi_service_funnel was added for providing coordination
    among duplicate service requests that receive a single response
  * Bugs were fixed and other improvements were added
    (see the ChangeLog for more detail)

June 4, 2020
  Version 2.0.0 released.
  * backwards incompatible changes:
    * CloudI API initialization has an optional terminate_return_value
      parameter (defaults to true for past functionality) that causes a
      terminate exception to be used if set to false, in
      C++/OCaml/Haskell
    * info_key_value_parse CloudI API function is now static in
      Go/JavaScript/Perl/PHP/Python/Ruby
  * Fixed CloudI Service API nodes_set (nodes configuration) use of
    connect and listen for hidden node connections
    (isolates one CloudI cluster from another by not creating a
     fully-connected network topology when connect == hidden)
  * Added the service configuration option restart_all to restart
    all service processes when one fails
  * Added the CloudI Service API services_suspend and services_resume
    functions to pause the processing of incoming service messages
  * Added suspend-related information to the CloudI Service API
    services_status output
  * Added C/C++ CloudI API functions for automatically freeing
    memory passed to return or forward
  * Erlang/OTP 23 support was added
  * Python 3.8 support was added
  * Haskell GHC 8.10.1 support was added
  * Bugs were fixed and other improvements were added
    (see the ChangeLog for more detail)

November 28, 2019
  Version 1.8.0 released.
  * backwards compatibility difference:
    * ACL strings do not get a "*" automatically appended on
      non-patterns, so exact strings may be used as an ACL string
  * Unicode support was added for external service configuration
    (file_path, args, env) and any other string or function use
  * CloudI API now has a shutdown function for external services
    (internal services always had the shutdown return value)
  * Fixed CloudI Service API services_add failure with multiple
    service configurations to handle data properly
  * Fixed service configuration option count_process_dynamic
    so it doesn't influence a pending service termination
  * Erlang services were added:
    * cloudi_service_api_batch executes services with batch queues
    * cloudi_service_cron sends service requests for cron expressions
    * cloudi_service_shell executes service request shell commands
  * Java service cloudi_service_htmlunit was created
    (see https://github.com/CloudI/cloudi_service_htmlunit/)
  * Haskell GHC 8.8.1 support was added
  * Bugs were fixed and other improvements were added
    (see the ChangeLog for more detail)

December 18, 2018
  Version 1.7.5 released.
  * Added CloudI Service API nodes_status function to provide
    current uptime, availability and cost information for
    any CloudI node (using Erlang monotonic time)
  * Now both "*" and "?" are wildcard characters in service name
    patterns that consume one or more characters, with "?" never
    matching the next character in the string (i.e. "/?/" matches "/a/"
     but never "/a/b/" while "/*/" will match either)
  * cloudi_service_http_cowboy was renamed to be
    cloudi_service_http_cowboy1
  * cloudi_service_router ssh server throughput was improved
  * All external dependencies were updated
  * Bugs were fixed and other improvements were added
    (see the ChangeLog for more detail)

September 16, 2018
  Version 1.7.4 released.
  * Added CloudI Service API services_status function to provide
    current uptime and availability information for any CloudI service
    (using Erlang monotonic time)
  * Added CloudI Service API code_status function to provide
    information about the installation and any runtime changes of
    the CloudI service files on the filesystem
  * ZeroMQ support was removed and SSH connectivity was added to
    cloudi_service_router as a better alternative
  * cloudi_crdt had small additions and an important bugfix
  * Added JSON support to cloudi_service_api_requests
  * Fixed JavaScript CloudI API service termination (no delay now)
  * Added support in Python, Python/C and Java CloudI APIs for
    non-member (static) functions (passed to the subscribe function)
  * Erlang/OTP 21.x compatibility
  * Haskell CloudI API dependencies were updated
  * Bugs were fixed and other improvements were added
    (see the ChangeLog for more detail)

February 27, 2018
  Version 1.7.3 released.
  * cloudi_crdt was added to provide an easy way to have replicated
    state among internal CloudI service processes
    (implementing a POLog CRDT with an Erlang map,
     see the Erlang count integration test for example use)
  * All cloudi_core and internal CloudI service time tracking has
    switched to monotonic time where it is advantageous
    (e.g., CloudI service restart times, cloudi_queue, etc.)
  * A bug preventing dest_list_deny and dest_list_allow from being
    used for cloudi_service_http_cowboy, cloudi_service_http_elli
    and cloudi_service_tcp was fixed (cloudi_service_children.hrl bug)
  * cloudi_queue will now perform a new service name lookup upon a
    retry if the pattern_pid() was not provided explicitly
  * The file_size_limit argument was added to cloudi_service_queue
    with the default value of 128MB
  * JavaScript CloudI API had a busy-wait bug causing excessive CPU
    consumption which has been fixed
  * Java 9 support was added
  * OCaml >= 4.06 support was fixed by including num as a
    compile-time dependency
  * CloudI execution now uses a default umask of 0027 which may be
    set with CLOUDI_UMASK (before the configure script is called)
  * Bugs were fixed and other improvements were added
    (see the ChangeLog for more detail)

September 13, 2017
  Version 1.7.2 released.
  * Service configuration option request_timeout_adjustment was modified
    to use Erlang monotonic time so timeout adjustments are not impacted
    by any OS time changes (now all CloudI service request
    timeout handling is using monotonic time)
  * Added CloudI Service API logging_set configuration option
    log_time_offset to log when the Erlang VM updates its time-offset
    with the time-offset change logged in nanoseconds
    (the offset is logged exactly when logging timestamps are changed)
  * configure script now accepts environment variables to set release
    configuration values: CLOUDI_ARG_NODE_NAME_SHORT,
    CLOUDI_ARG_NODE_NAME_LONG, CLOUDI_ARG_NODE_COOKIE, CLOUDI_PID_FILE
    (can be used to avoid manual vm.args modifications)
  * Many deployment changes to make CloudI use robust:
    * The release script is safe for root use
      (external environment variables are blocked,
       functionality is locked down, manages a pid file correctly, etc.)
    * Execution now occurs within the logging directory so any
      crash dump output is put there automatically
  * cloudi_service_null is an Erlang service added to provide a simple
    way of consuming CloudI service requests
    (during testing and/or to handle invalid URL service names)
  * cloudi_service_request_rate was added to the CloudI release to
    provide an easy way of testing max throughput
  * cloudi_service_http_cowboy and cloudi_service_http_elli now use an
    update_delay argument to apply a change to timeout_async and/or
    timeout_sync performed with the CloudI Service API services_update
  * Bugs were fixed and other improvements were added
    (see the ChangeLog for more detail)

June 7, 2017
  Version 1.7.1 released.
  * backwards compatibility difference:
    * cpg (CloudI Process Groups) source code was changed to minimize
      distributed Erlang communication (and local messaging) without
      attempting to remain compatible with cpg versions before 1.7.1
      (i.e., prevent CloudI 1.7.1 nodes from communicating with older
       nodes by using different cookie settings or other means).
    * Using the CloudI API functions send_sync or recv_async during
      the service's initialization previously returned an error,
      but will now cause the service to crash, to pursue fail-fast
      operation and to keep the effect the same for both internal and
      external services.
  * All CloudI source code is under a MIT license instead of a
    BSD-style license to make reuse simpler and to be GPL-compatible
  * The chroot external service configuration option was added
    (https://cloudi.org/api.html#2_services_add_config_opts)
  * The order external service configuration options are applied
    changed from owner, limit, nice, directory
    to chroot, limit, nice, owner, directory which means that the
    user/group responsible for running CloudI influences the
    permissions for chroot, limit, nice (and cgroup).
    This order will not need to change in the future.
  * Erlang/OTP 20.0 compilation/runtime works
  * Bugs were fixed and other improvements were added
    (see the ChangeLog for more detail)

March 29, 2017
  Version 1.7.0 released.
  * backwards compatibility difference:
    * The C CloudI API (not the C++ CloudI API) had a small change to
      facilitate the use of thread local data with the callback
      function arguments order changing to match the other programming
      languages that lack (or avoid) state objects
      (C, Erlang, Go, Haskell, OCaml).
      All CloudI API callback functions have the arguments:
      Type, Name, Pattern, RequestInfo, Request,
      Timeout, Priority, TransId, Source (in this order).
      The programming languages with state objects have the
      two arguments: State, API, before the common arguments with
      State as a state object (normally not present as a
      function argument).  The programming languages without
      state objects have the two arguments (State, API) after the
      common arguments.
      The C examples have been updated to show the changes
      (https://cloudi.org/tutorials.html#cloudi_examples).
      More function argument discussion is at
      https://cloudi.org/faq.html#1_Reactive
    * The CloudI API implementations had the function
      request_http_qs_parse name change to info_key_value_parse
  * The Go CloudI API was added
    (requires the configure argument --enable-go-support and
     Go (gc) >= 1.6)
  * The Haskell CloudI API was added
    (requires the configure argument --enable-haskell-support and
     GHC >= 7.10.3, cabal-install >= 1.22)
  * The OCaml CloudI API was added
    (requires the configure argument --enable-ocaml-support and
     OCaml >= 4.03.0)
  * The CloudI Service API function logging_stdout_set was added to
    allow all CloudI logging to be sent to stdout
  * The count integration test was added to show how thread local
    state works in all supported programming languages
    (https://cloudi.org/tutorials.html#cloudi_examples).
  * A bug with CloudI Service API services_update usage on
    external services was fixed, to allow the service configuration
    values: timeout_async, timeout_sync, and the service configuration
    options: priority_default, request_timeout_adjustment, to
    dynamically change during runtime if no new OS process is created
    (to utilize the new values).
  * A bug was fixed to make the use of the service configuration
    option count_process_dynamic more dependable for external services
    written in Perl, PHP, Python, and Ruby.
  * lager was removed; hut is now used for exometer logging.
    Erlang logging integration was added to the modules
    cloudi_logger_lager and cloudi_logger_hut
    (to use CloudI logging instead of lager or with hut)
  * The default external service configuration buffer_size setting
    changed from 16384 to 65536
    (to match the same Linux localhost MTU change)
  * UTF8 is now logged properly from Erlang source code
  * Bugs were fixed and other improvements were added
    (see the ChangeLog for more detail)

January 11, 2017
  Version 1.6.0 released.
  * backwards compatibility difference:
    * Functions deprecated in the 1.3.3 CloudI release have been removed
    * Usage of the 'immediate' atom for the timeout value with the
      cloudi_service Erlang module and the cloudi Erlang module is deprecated,
      use the 'limit_min' atom instead for the same value
    * The minimum allowable values for service configuration
      (both adding a new service and updating an existing service) of
      timeout_async and timeout_sync has changed from
      101 milliseconds to 499 milliseconds to be consistent with
      the value that 'limit_min' represents
    * The service configuration options
      request_timeout_immediate_max and response_timeout_immediate_max
      had their meaning change to rely on a greater than or equal to
      comparison instead of a greater than comparison, though the same
      default behavior is preserved with this change
      (https://cloudi.org/api.html#2_services_add_config_opts)
  * Now cloudi_core doesn't use any port drivers or NIFs except what is
    provided within Erlang/OTP, and process dictionary use is minimal
  * The Elixir module CloudILogger is now included in the cloudi_core
    Erlang application to simplify usage of CloudI in Elixir source code
  * Bugs related to CloudI logging syslog integration have been fixed and
    more options for syslog use have been added
    (https://cloudi.org/api.html#2_logging_syslog_set has more information)
  * The restart_delay service configuration option was added
    (https://cloudi.org/api.html#2_services_add_config_opts_restart_delay)
  * CloudI service restarts have been made synchronous to ensure all
    termination has completed before initialization of new processes begins
    (to improve reliable management of global state during a restart)
  * All service configuration timeout values that take milliseconds also
    accept the Erlang atoms 'limit_min' and 'limit_max' where 'limit_max'
    is a concept similar to the 'infinity' atom in Erlang source code,
    though it does represent 49.7 days in milliseconds, so be careful about
    its use (no one wants to wait 49.7 days to see a failure)
  * All CloudI API implementations now handle a null return value as a response
    to create a null response, if the programming language has a concept of
    null (for more information, see the null integration test
    https://cloudi.org/tutorials.html#cloudi_examples and/or read about
    a null response at https://cloudi.org/faq.html#4_Null)
  * All CloudI API implementations now put stdout and stderr into unbuffered
    mode to ensure CloudI service output is logged as quickly as possible
  * Bugs were fixed and other improvements were added
    (see the ChangeLog for more detail)

October 7, 2016
  Version 1.5.4 released.
  * An important bugfix was added for internal services that use
    both CloudI service requests and info messages at high request
    rates with the duo_mode service configuration option set to true
    (service state returned from the info message handling wasn't
     always saved previously under these conditions)
  * Request rate testing was done both with and without the persistence
    of service request data (using cloudi_service_queue in destination mode)
    as described at https://cloudi.org/faq.html#5_LoadTesting
  * The 'nice' and 'cgroup' service configuration options were added for
    external services
  * The logging_set CloudI Service API function was added to allow
    multiple logging modifications to occur dynamically
    (similar to nodes_set for CloudI nodes configuration)
  * Bugs were fixed and other improvements were added
    (see the ChangeLog for more detail)

September 15, 2016
  Version 1.5.3 released.
  * services_update is a new addition to the CloudI Service API for
    updating any service without downtime, i.e., module hot-code reloading
    with internal services and OS process restarts with external services
    while CloudI ensures service requests are not lost and service request
    handlers are not interrupted in any of the service processes or threads
    (see https://cloudi.org/api.html#2_services_update for more information)
  * A Java user tutorial has been added based on the work of Bruce Kissinger
    (https://cloudi.org/tutorial_java.html)
  * The Java CloudI API can now use method references with Java 8
  * New service configuration options were added or improved:
    'directory', 'dispatcher_pid_options', 'init_pid_options',
    'request_pid_options', 'info_pid_options'
    (https://cloudi.org/api.html#2_services_add has more information)
  * Many of the database services were removed with their dependencies,
    from the main repository due to service development demonstrating that
    failures remain isolated when using a database client locally within a
    service (database services can help scale usage and make sure it is
    fault-tolerant, but only after the service business logic is in a stable
    state and excluding these services will help guide developers)
  * cloudi_service_monitoring was improved:
    * Any Erlang process can create or update metrics now
    * cloudi.log output can be monitored with
      aspects_log_before or aspects_log_after
    * All CloudI service related metrics now have a static metric name,
      identified with TYPE.FILENAME.INDEX instead of the service ID
      as described in the ChangeLog file
  * Erlang internal services now have two optional behaviour functions
    (some services choose to use only one of the functions):
    * cloudi_service_handle_request/11
    * cloudi_service_handle_info/3
  * Bugs were fixed and other improvements were added
    (see the ChangeLog for more detail)

December 23, 2015
  Version 1.5.1 released.
  * cloudi_service_monitoring is a new CloudI service that provides
    metrics based on the Erlang VM and all the running CloudI services
    with exometer and folsom
  * cloudi_service_http_rest is a new CloudI service to simplify the creation
    of HTTP REST API handlers
  * CloudI service efficiency was improved by switching to maps with 18.x
  * CloudI now utilizes the new time warp functionality while retaining
    globally unique transaction ids
  * The CloudI logging output now has an entry for the function/arity info
    which is captured in Elixir and can be provided in Erlang (until EEP45)
  * JavaScript CloudI API now works properly with node.js version > 0.12.1
  * Loadtests were ran (https://cloudi.org/faq.html#5_LoadTesting)
  * Bugs were fixed and other improvements were added
    (see the ChangeLog for more detail)

April 12, 2015
  Version 1.5.0 released.
  * backwards compatibility difference:
    * cloudi module (Erlang/Elixir-only usage) now returns a 2 element tuple
      with the 1st element as the result (original return value) and the
      2nd element as the modified Context data (or the Dispatcher pid if a
      Dispatcher pid was provided instead of a Context)
      * Was a necessary change to keep the transaction id time as
        strictly monotonically increasing with the changes in Erlang 18.x
        that deprecate erlang:now/0
      * Allows a lazy destination refresh to update the service name lookup
        data so the developer doesn't need to handle the update manually
      * The change impacted the return value of internal service
        external interface functions
      * The service application was changed to depend only on the
        cloudi_service module instead of the cloudi module to
        make its usage clearer and avoid Dispatcher pid value handling
      * Despite the return value changes, only the minor version number
        of CloudI was incremented due to the interfaces being outside the
        main documentation
  * External services can now set OS process resource limits with the
    'limit' service configuration option
    (https://cloudi.org/api.html#2_services_add_config_opts_limit)
  * A few new CloudI data structures:
    cloudi_queue, cloudi_future, cloudi_service_future
    (cloudi_queue can handle service request validation, failures, and retries
     with in-memory internal service data)
    (cloudi_future and cloudi_service_future provide Futures for
     Erlang processes (sending to CloudI services) and
     internal CloudI services, respectively)
  * cloudi_service_validate is a new CloudI service for validating
    service requests with the requests using the service as a proxy
    (similar functionality was added to cloudi_service_quorum and
     cloudi_service_router, though cloudi_service_router is forwarding
     the service request instead of sending it)
  * The Python CloudI API now handles unicode stdout/stderr data properly
    (immediate flushing of stdout/stderr is now fixed for Python 3 usage)
  * Bugs were fixed and more documentation was added
    (see the ChangeLog for more detail)

December 20, 2014
  Version 1.4.0 released.
  * JavaScript/node.js, PHP and Perl are now supported programming languages
    with their own CloudI API implementations
  * A Quick Start now has intros for all supported programming languages
    (https://cloudi.org/#quick_start)
  * Loadtests were ran (https://cloudi.org/faq.html#5_LoadTesting)
  * Various bugs were fixed

September 30, 2014
  Version 1.3.3 (beta) released.
  * backwards compatibility difference:
    * Some minor functions were deprecated in the cloudi_service module and the
      source code was moved to separate modules
      (cloudi_environment, cloudi_service_name, cloudi_request,
       cloudi_request_info, cloudi_key_value)
    * The CloudI Service API had some functions renamed with the older name
      deprecated (loglevel_set became logging_level_set and
      log_redirect became logging_redirect_set)
    * In version 1.4.0 of CloudI the cloudi_service behaviour will have a
      Timeout parameter in both the cloudi_service_init callback and the
      cloudi_service_terminate callback (if you want to start using it now,
      make sure cloudi_core is compiled with the CLOUDI_SERVICE_NEW define,
      a CLOUDI_SERVICE_OLD macro will exist in version 1.4.0 to avoid the
      change so older services can run without modification)
    * cloudi_service_api_requests now provides simpler URL paths for the
      CloudI Service API (while continuing to support the older URL paths)
      (https://github.com/CloudI/CloudI/tree/master/src/service_api#api)
    * Python 3 usage requires that the request_info, request,
      response_info, and response data be bytes
  * Elixir is now supported officially and has an example at
    https://github.com/CloudI/CloudI/tree/master/examples/Elixir.HelloWorld1
  * Python 3 is now supported by the Python CloudI API
    (both the cloudi module and the cloudi_c module)
  * queue_size is a service configuration option added so any service may
    limit their incoming service request queue by an amount of memory (in kB)
    (queue_limit provides a count limit and both can be used together)
  * Support for Aspects (from AOP, Aspect-Oriented Programming) were added
    as service configuration options
    (aspects_init_after, aspects_request_before, aspects_request_after,
     aspects_info_before, aspects_info_after, aspects_terminate_before)
    so a series of Erlang (or Elixir) functions can be executed
    before and/or after a cloudi_service behaviour function is executed and
    possibly modify the service state (for both internal and external services)
    (https://cloudi.org/api.html#2_services_add_config_opts_aspects_init_after)
  * Service initialization and termination are now enforced to be synchronous
    as described here (for both internal and external services):
    * initialization must be completed before the next service in a sequence
      (including the configuration file list of services) is started
    * termination causes the service to stop and terminate within the
      termination timeout defined by slightly less than MaxT/MaxR
      (clamped to [1..60] seconds)
  * lager formatters and lager backends are now supported as described at
    https://cloudi.org/api.html#2_logging_formatters_set
  * cassandra CQL support was added by Irina Guberman
    (as cloudi_service_db_cassandra_cql)
  * Added Riak support with the cloudi_service_db_riak service
  * Added OAuth v1 support with the cloudi_service_db_oauth1 service
  * The cloudi_service_db_pgsql service now supports
    3 separate postgres drivers and provides common output for all 3
    (wg epgsql, semiocast pgsql, and epgsql epgsql (new))
  * The cloudi_service_db_mysql service was updated to use the
    Eonblast fork of emysql and supports the same common output as
    cloudi_service_db_pgsql
  * cloudi_service_http_cowboy was updated to use Cowboy 1.0.0
  * cloudi_service_filesystem now supports write operations as append/insert or
    truncate with byte ranges that can also be used to read
  * Many bugfixes, other additions, and documentation improvements
    (see the ChangeLog for more detail)

May 31, 2014
  Version 1.3.2 (beta) released.
  * Fixes for Erlang/OTP 17.0 compilation
  * Improved node auto-discovery functionality and configuration
    * Add cloudi_service_api:nodes_set/2 for dynamically configuring
      CloudI nodes configuration
    * EC2 node discovery now works as expected, selecting based on
      tags and/or security groups
    * Allow node connections to be hidden for more complex network topologies
    (see https://cloudi.org/api.html#2_nodes_set)
  * Add cloudi_service_queue for persistent queuing of service requests
    with CT tests
  * Add cloudi_service_filesystem file update notification service requests
    (see notify_one and notify_all configuration)
  * The cloudi_service_http_cowboy service has many different additions:
    * Added websocket_protocol for creating a mapping between a protocol id
      and the TransId of websocket service requests to avoid contention
    * Added websocket_subscriptions for adding additional websocket connection
      subscriptions for receiving service requests, conditional on the
      connection URL (to simplify messaging to groups of websockets)
    * websocket_connect and websocket_disconnect can be set to be either
      async or sync service requests
    * use_websockets == exclusively for only using websockets
  * Add service name pattern support to cloudi_service_router
    (to map from a service name pattern to a new service name destination)
  * The cloudi_service_db_pgsql now provides either the
    https://github.com/semiocast/pgsql or https://github.com/wg/epgsql
    driver along with a separate configuration option
    for providing common output
  * Log output now reflects the default (tuple) service configuration format
  * Various bugfixes, small additions, and documentation improvements

February 1, 2014
  Version 1.3.1 (beta) released.
  * Added a demo of CloudI scaling a game server (a MUD) that is 20+ years old
    (see https://github.com/okeuday/sillymud)
  * Added the service configuration option count_process_dynamic to
    dynamically adjust the number of service processes based on the
    incoming service request rate
    * The hibernate service configuration option can provide
      rate based service hibernation now
  * The C++ CloudI API can provide backtrace information from
    CloudI::API::backtrace() when configured using --with-cxx-backtrace
  * A few of the new internal service functions:
    * cloudi_service_api:service_subscriptions/2
    * cloudi_service:recv_asyncs/4
    * cloudi_service:source_subscriptions/2
    * cloudi_service:context_options/1
    * cloudi_service:environment_transform/1
    * cloudi:trans_id_age/1
  * The cloudi module can use lazy destination refresh methods and works best if
    you update the destination data with the cloudi:destinations_refresh/2
    function
  * Latency of the following services was reduced:
    * cloudi_service_http_cowboy
    * cloudi_service_http_elli
    * cloudi_service_tcp
  * Fixed cloudi_service_quorum and added a byzantine mode
  * Added the cloudi_service_router internal service
  * The cloudi_service_filesystem can refresh its data after a
    configured time period
  * Now CloudI has separate repositories for each CloudI Erlang application
    if you want only internal service support with simple rebar integration
    (see https://github.com/CloudI/cloudi_core#readme)
  * The service Erlang application is provided to make service creation
    a bit less complex (see https://github.com/CloudI/service)
  * The automatic loading of an internal service can be disabled with the
    automatic_loading service configuration option set to false
    (see the hello_world5 example to understand why)
  * Service configuration now can use a proplist format, if you dislike
    the tuple format
    (see https://github.com/CloudI/CloudI/blob/master/examples/hello_world5/apps/hello_world5/src/hello_world5_app.erl#L57 or
     https://github.com/CloudI/CloudI/blob/master/src/lib/cloudi_core/src/cloudi_service_api.erl#L186)
  * Various bugfixes, small additions, and documentation improvements

October 18, 2013
  Version 1.3.0 (beta) released.
  * backwards compatibility difference:
    * CloudI Service API function services_add now returns a list of
      service UUIDs which can then be used in the other CloudI Service API
      functions (see the API HTML documentation or the
      cloudi_service_api module for details)
  * cassandra support was added by Mahesh Paolini-Subramanya
  * elasticsearch support for mapping and aliases was added
    by Mahesh Paolini-Subramanya
  * A service name pattern matching bug was fixed after being reported
    by Anton Ryabkov (an unsubscribe now removes a cpg group entry, if
    the group is empty, to avoid shadowing a pattern match)
  * CloudI API function cloudi_service:mcast_async_active was added
  * All the included internal CloudI services are now separate Erlang/OTP
    applications, to provide better management of their dependencies
  * The hello_world4 example was added to show how an Erlang/OTP release with
    CloudI can be created with relx
  * The hello_world3 example (rebar usage) was simplified,
    (rebar's HEAD is currently broken, refer to example README for details)
  * The service configuration options monkey_latency and monkey_chaos were
    added to provide a way of changing service performance and/or stability 
    for evaluating system resilience during service problems
    (http://techblog.netflix.com/2011/07/netflix-simian-army.html)
  * cloudi_service_http_cowboy had a few additions:
    * multipart support was added
    * content_types_accepted, set_x_forwarded_for, and status_code_timeout
      are configuration options
    * "status" key usage in ResponseInfo provides the HTTP status, as with
      normal HTTP protocol responses
  * A few new internal services were added:
    * cloudi_service_db_cassandra
    * cloudi_service_db
    * cloudi_service_tcp
    * cloudi_service_udp
    * cloudi_service_quorum
  * Various bugfixes, small additions, and documentation improvements

August 9, 2013
  Version 1.2.5 (beta) released.
  * elasticsearch integration was added in cloudi_service_db_elasticsearch.
  * External service configuration strings provided for the executable
    file path, the executable command line arguments, and the executable
    environment variables, now can expand environment variables set in the
    shell executing the Erlang VM (e.g., "$USER" or "${USER}" syntax).
  * Internal services now have a few more service configuration options:
    * hibernate - always makes the service processes hibernate to conserve
      memory by doing extra garbage collection processing
    * reload - will automatically reload the service module or all modules
      within a service application when the beam file is updated
  * Both external and internal services can set the scope
    service configuration option to give service name lookups and subscriptions
    a separate scope, minimizing contention when using an immediate destination
    refresh method.
  * Tests with common test, eunit, and PropEr are now used to validate the
    build.  An initial common test was added to test cloudi_service_db_pgsql.
  * The cloudi Erlang module received fixes so that it is a better match to the
    subset of the CloudI API (the cloudi_service Erlang module) it implements.
  * The services_search function was added to the CloudI Service API which
    returns the services that have subscribed to a service name.
  * cloudi_service:service_name_parse/2 was added to make it simpler to
    parse service name patterns.
  * The cloudi_core Erlang application is now the only dependency required
    when including CloudI in an Erlang release.  See the hello_world2
    example for details.
  * rebar integration for using the CloudI repository as a rebar dependency
    was added.  See the hello_world3 example for details.
  * Added a lot of configuration validation to prevent any problems with
    invalid configuration data for services, ACLs, etc.
  * Small fixes and additions were added to the websockets integration within
    cloudi_service_http_cowboy.  use_client_ip_prefix is a new option
    within cloudi_service_http_cowboy.
  * cloudi_service_http_elli was added to provide elli integration.
    More load testing is required to determine how it compares to
    cloudi_service_http_cowboy.
  * ZeroMQ detection on OSX was fixed.

June 20, 2013
  Version 1.2.4 (beta) released.
  * The external service "local" (i.e., "default") protocol configuration
    option has been fixed and was tested on OSX successfully.  The problem was
    with the unix domain socket initialization, so it doesn't affect the
    loadtest results done for the 1.2.2 release
    (see src/tests/http_req/loadtest/results_v1_2_2/201306_summary.pdf).
    The default configuration external service protocol configuration, as well
    as the quickstart remain with the "tcp" option, to avoid blocking
    people that are not concerned about the efficiency benefits and give
    more time for testing it.
  * WebSockets support was added to the cloudi_service_http_cowboy
    internal service.  To handle websocket connections, just use the
    "{use_websockets, true}" configuration option, as shown for port 6464
    within the default configuration.  The example is at:
    src/tests/http_req/public_html/websockets.html .
  * Various fixes were added for the R16B01 release (crypto application usage)
  * cowboy was updated to 0.8.6
  * The cloudi_service_api module was added so that the CloudI Service API
    can be accessed within the same VM with Erlang function calls
    (the service providing JSON-RPC and HTTP integration for the CloudI
     Service API had a name change from cloudi_service_api to
     cloudi_service_api_requests)
  * Two examples of different ways to release Erlang applications with
    CloudI exist in the examples directory as hello_world1 and hello_world2.
    hello_world1 shows how to let CloudI run your Erlang source code as a
    service, while hello_world2 shows you a basic Erlang release
    with external source code that has CloudI as a dependency.
  * Infrequent use cases of the internal service init function required some
    fixes to prevent errnoeous usage.  The functions send_sync and recv_async
    should not be used within an internal service init function, similar to
    the restriction on gen_server:call for the gen_server OTP/Erlang
    behaviour (you can always send a message to self() and handle it within
    the cloudi_service_handle_info/3 to utilize these functions).

June 8, 2013
  Version 1.2.3 (beta) released.
  * Added internal service purging when services are removed.
    The service module, or service application modules are purged after the
    service has been stopped, and the service applications (if any were used)
    has been stopped.  The functionality works with modules, applications and
    releases (within a .script file).  When applications are stopped and
    purged, only applications which are not dependencies for other running
    applications are removed.
  * Focused on bugs/fixes, mainly for OSX.  The external service "local" 
    protocol configuration option did not work properly on some installations
    of OSX, so the default CloudI configuration file now uses the "tcp"
    protocol configuration option (to be the same as releases before 1.2.2).
    The problem with the "local" protocol configuration option may be limited
    to slower machines (the problem is caused by execution spending too much
    time within a socket accept function call within an Erlang NIF).
    The "local" protocol configuration option on OSX will be addressed in a
    later release.

June 1, 2013
  Version 1.2.2 (beta) released.
  * Performance was improved further for external services with the addition
    of UNIX domain socket support as the "local" protocol.  The python_c
    CloudI API now has minimal latency.  The Erlang, C/C++, and Java CloudI
    APIs now have similarly low latency (20-40ms latency mean max,
    130-170ms latency max sample, for 20k connections at 10k req/s with the
    "local" protocol).  Now all the CloudI API implementations have been
    modified to send the request response before an exception is thrown to
    avoid imposing any extra request latency.
  * v1 UUIDs now have the correct variant bits set.  This fix makes the UUIDs
    backwards incompatible (if older UUIDs have been stored in a database).
  * Prevously, external service buffer sizes where assigned after being doubled.
    Now, that is no longer the case.  If that is a concern, make sure to double
    your configured buffer size (specified in the external service
    configuration).
  * Problems with the CloudI database services have now been fixed.  It is now
    true that the cloudi_service_init/3 self() process is the Dispatcher
    Erlang process used in future service function calls.  That will remain
    true in the future to maintain consistency with OTP behaviours.
    However, it is mainly for proper link/monitor creation, it is still
    best to use cloudi_service:self/1 when retrieving the service's Erlang
    process.
  * Added the "cloudi" module for Erlang usage of CloudI services within
    external Erlang processes.
  * Added the "cloudi_x_" scope (i.e., namespace) prefix to all external
    CloudI dependencies so that it is easier to include CloudI with other
    Erlang applications.  This change will impact any Erlang applications
    that currently use CloudI and CloudI external dependencies, but have not
    yet included their own version of the external dependencies.
  * Added proper support for loading Erlang applications and Erlang releases
    that include a CloudI service module.
  * Added newest/oldest destination refresh method options.
  * Now external service configuration can use the "default" atom for either
    the protocol and/or the buffer size.  The default protocol is the new
    "local" protocol and the default buffer size is currently 16384 bytes
    (Linux localhost (inet) MTU) but may change in the future based on
    further testing.

March 30, 2013
  Version 1.2.1 (beta) released.

  * Performance issues with the version 1.2.0 release were addressed here.
    It became clear after loadtesting that using a single Erlang process
    instead of two Erlang processes for each internal service caused much
    more latency under heavy load for internal services that receive a
    large amount of throughput.  While this may be an obvious conclusion,
    the latency was judged to be significant after loadtesting, so duo_mode
    was added as an internal service configuration option to provide a
    service with two Erlang processes instead of a single Erlang process
    (which provides performance similar to what was seen previous to
     version 1.2.0, but with slightly less latency, caveat: python_c
     suffered due to changes for the request timeout adjustment).
    The duo_mode option being set to true makes sure to provide an Erlang
    process for receiving service requests while the main Erlang process
    handles sending service requests, so that the service messaging flow
    is able to more fully exploit the Erlang VM scheduling
    (i.e., duo_mode is a duplex communication mode).
  * The exception handling overhead has become a source of latency under load
    when using the request_timeout_adjustment.  The request_timeout_adjustment
    being set to false avoids the extra latency for all CloudI API
    implementations except python_c (so the python_c performance gains
    were sacrificed due to usage of python exception handling, with the
    version 1.2.0 release).  So, the python_c latency will be addressed
    in the next release.
  * Added more service configuration options:
      * request_pid_uses, request_pid_options, info_pid_uses, info_pid_options -
        to provide more control over internal service garbage collection
        characteristics
      * duo_mode - to provide better performance for high-throughput internal
        services
      * response_timeout_adjustment - to avoid latency typical with the
        erlang:cancel_timer/1 function call
  * cowboy was updated to 0.8.2 and misultin was removed
  * loadtests were done to verify the reduced latency and to test the new
    service configuration options
    (results+config are at src/tests/http_req/loadtest/results_v1_2_1/)
  * ZeroMQ integration received more testing and changes to make it more robust

February 19, 2013
  Version 1.2.0 (beta) released.

  * Erlang >= R15B01 is now required due to callback/behavior changes
  * misultin was removed, cowboy now provides better functionality
    (misultin was also broken due to parameterized modules usage)
    cowboy was updated to 0.8.0
  * The documentation and CloudI source code changes so that "job" is no
    longer used to refer to services.  Now "service" is used consistently
    to help prevent confusion.  This change means that Erlang services
    (i.e., internal services) must now use the cloudi_service behavior
    instead of the cloudi_job behavior and the callback names reflect the
    same change.  The CloudI Job API is now referred to as the
    CloudI Service API.
  * A Quick Start and API documentation was added to help people
    learn about CloudI
  * A minor CloudI API change occured that affects Erlang services:
    cloudi_service:recv_async now always returns
    {ResponseInfo, Response, TransId} to be consistent with
    functionality in external services
  * Important bugfixes and improvements are included in this release
      * cloudi_service:unsubscribe will now properly unsubscribe a single
        instance of the service name pattern
      * Many improvements to internal services and
        the python_c external services
      * the ZeroMQ integration service has been fixed
      * the CloudI Service API had some minor issues fixed
      * the flood and messaging tests had some fixes
      * the bug with ACL string usage (from 1.1.1) was fixed
  * The request_timeout_adjustment service configuration option was added
    to make all service requests have their timeout decremented by the
    service request handler's execution time (defaults to false)
  * ZeroMQ v3 is now the default version if it is enabled
    (version 3.2.2 is used, if it isn't already installed)

February 4, 2013
  Version 1.1.1 (beta) released.

  * use patterns instead of prefixes for ACL strings
  * add the following destination refresh methods:
    immediate_furthest, lazy_furthest,
    immediate_local, lazy_local,
    immediate_remote, and lazy_remote
  * build system fixes and documentation fixes for installation
  * fix CloudI API uuids to be completely standard v1
  * fix external service queuing during initialization

October 30, 2012
  Version 1.1.0 (beta) released.

  * multiple loadtests to show the performance of all supported programming
    languages with the two supported HTTP servers, receiving 10,000 requests/sec
  * support for the cowboy HTTP server was added, which provides a
    significant reduction in HTTP request latency for Erlang services
    (based on the loadtest results)
  * Python with C integration provides a more efficient Python CloudI API
    (at least a 400% speedup, based on the loadtest results when using the
     Python module "cloudi_c" instead of "cloudi")
  * OSX configuration and compilation now works without problems
  * recv_async within the CloudI API can now choose whether to consume the
    response it returns
  * the hexpi test was abstracted to create the cloudi_job_map_reduce
    Erlang behaviour for fault-tolerant processing of iterative algorithms
  * various bug fixes for the tests
  * source code organizational improvements

June 24, 2012
  Version 1.0.0 (beta) released.

  * loadtest to show performance of various languages under load
    (results/config at src/tests/http_req/loadtest/)
  * HTTP support is now improved after tweaks during loadtesting
  * virtual host option in HTTP support
  * a few bugfixes

April 14, 2012
  Version 0.2.0 rc2 (beta) released.

  * many bugfixes
  * messaging test is now implemented in Erlang, C++, Ruby, Java, and Python
  * added alternative function pointer parameters for C++ CloudI API usage
    so that there is no need to create std::string objects

March 26, 2012
  Version 0.2.0 rc1 (beta) released.

  * support for Erlang R15
  * added support for using service name patterns
    (i.e., names that include the "*" wildcard character)
  * added priority queueing to Erlang services
  * added timeout handling to expire queued requests and now update the request
    timeout based on the time spent queued
  * added log output redirection with automatic partition tolerance
    (i.e., redirect local log output to a remote node and if contact with the
     remote node is lost, log locally until the connection is reestablished)
  * added floating point usage for configuring process and thread counts
    (so that it represents a ceil for numbers > 1.0 or
     a round for numbers < 1.0 when using it as a multiple of the
     number of cores (i.e., Erlang VM scheduler threads))
  * added service options to the CloudI configuration so that typical
    defaults are easily modified
  * other fixes and enhancements (see ChangeLog)

December 12, 2011
  Version 0.1.9 (alpha) released.

  * added request_info/response_info parameters to CloudI messages
  * added the priority parameter to CloudI messages (-128 high to 127 low)
  * new C++ CloudI API (as an alternative to the C CloudI API)
  * prevent CloudI logger flooding from misbehaving services
  * other fixes and enhancements (see ChangeLog)

September 6, 2011
  Version 0.1.8 (alpha) released.
  Changes for HTTP support and robust C API usage.

June 23, 2011
  Version 0.1.7 (alpha) released.
  More build system improvements.

May 14, 2011
  Version 0.1.6 (alpha) released.
  Many build system improvements.

April 25, 2011
  Version 0.1.5 (alpha) released.
  The Job API is finalized with using UUIDs for jobs_remove() and the addition
  of the jobs() request.

April 15, 2011
  Version 0.1.4 (alpha) released.
  The release includes many changes to make the 0.1.x source code robust.
  The Job API now exists with a JSON-RPC interface over HTTP
  (in version 0.0.10 this was the API).  The Job API facilitates dynamic
  configuration of all CloudI functionality.

February 23, 2011
  Version 0.1.0 (alpha) rewrite is now available and
  many changes occurred between the CloudI version 0.0.10 and version 0.1.0.
  The changes are summarized below:
  
  * CloudI is now a naturally master-less distributed system
    (i.e., requires no special configuration or redundancy)
  * messaging can occur between services (i.e., jobs) which
    may exist on other CloudI nodes
  * all service (i.e., job) names rely on strings rather than dynamic atoms,
    lookups use the trie data structure for efficiency close to the performance
    of the process dictionary (the fastest Erlang data structure)
  * cnodes are no longer used for external service (i.e., job) communication,
    instead sockets are used for each thread (either UDP or TCP can be used)
  * external services (i.e., jobs) are no longer implemented in dynamic
    libraries but are instead implemented in executables.  this change makes
    running various VMs or interpreters easy and avoids dynamic library link
    dependency problems with various version dependencies
    (i.e., helps support Java, Python, etc.)
  * HTTP can be used to call services, but JSON-RPC is not supported like it
    was in 0.0.10 (support for JSON-RPC will be added again soon)
  * a normal autotools/rebar build system is used that doesn't attempt to
    install critical dependencies locally (it just requires that they exist)
  * restarting stopped (e.g., SIGSTOP) OS processes is not implemented in
    0.1.0 (but may be added back, as necessary)

March 26, 2010
  "CloudI: A Cloud as an Interface (EXPANDED)"
  Presentation at the Erlang Factory, San Francisco Bay Area, California, USA
  Version 0.0.9 (alpha)

November 12, 2009
  "CloudI: A Cloud as an Interface"
  Presentation at the Erlang User Conference, Stockholm, Sweden
  Version 0.0.8 (alpha)

