Introduction

The core development team publishes official images on the AWS Marketplace, which lets you quickly get started with Kill Bill in the cloud.

Installation via Our Standalone AMI

Running Kill Bill on AWS using our official AMI lets you deploy Kill Bill, Kaui and MySQL in a single EC2 instance. It is perfect for test environments or for small production deployments where high availability isn’t a concern.

After launching the AMI you should have a setup that looks like the following:

standalone deployment

Setup Steps

  1. Start the installation process by going to AWS Marketplace: click Continue to Subscribe and accept Terms. You will need some AWS permissions aws-marketplace:* to click on the Subscribe button.

  2. After a few minutes, click Continue to Configuration and Continue to Launch

    • Make sure you enable the `auto-assign `public IP:

std enable public ip

  • Make sure you open the ingress port 443, and 8443 on your security group:

std security group

  • Make sure you specify an existing known key-pair (for SSH access)

std key pair

Upon success, once the instance is running, Kill Bill is running on port 8443 and Kaui on port 443.

You can log-in to Kaui by going to https://<INSTANCE_IP_>:443 (make sure your IP address can address this port, or add it to the security group as needed). Default credentials are: admin/password. The first few requests might be a bit slow as Kill Bill initializes itself.

Take a look at our Getting Started guide for an introduction to Kaui.

Configuration

SSL Certificates

We have configured nginx to listen to port 443 (and forward traffic to KAUI) and so by default accessing the service from a web browser will show a Not Secure site. In order to make the site secure, you will need to add a valid certificate. The easiest option to add the certificate is to rely on Let’s Encrypt, a Certificate Authority (CA) that provides an easy way to obtain and install free TLS/SSL certificates.

The steps to add the certifcate are fairly simple and rely on a tool called cerbot.

[1]. Verify cerbot is installed or install it

Our latest image should have cerbot by default, but if not this can be added using the following:

Note: Check our TroubleShooting section to see how to login to the EC2 machine

# As root sudo su -
sudo su -
# Install cerbot if not already present
add-apt-repository -y ppa:certbot/certbot
apt install -y python-certbot-nginx

[2]. Stop all services

cerbot will need to have access to port 80 and 443

# Stop kaui
> service kaui stop
# Stop killbill
> service killbill stop
# Stop nginx
> service killbill nginx

Make sure your AWS security groups allow incoming traffic on port 80 and port 443 for all IPs

[3]. Setup your domain’s CNAME Record to point to the public DNS of your EC2 instance.

Create a CNAME to map your public DNS — e.g https://ec2-18-234-168-57.compute-1.amazonaws.com — to a legit CNAME, otherwise cerbot will fail with the following error: `Error creating new order

Cannot issue for "ec2-18-234-168-57.compute-1.amazonaws.com": The ACME server refuses to issue a certificate for this domain name, because it is forbidden by policy`

The configuration of your CNAME needs to happen from the UI of your domain provider (Namecheap, Cloudflare, …​)

[4]. Modify the nginx killbill.conf server sections

The server_name by default specifies _. Instead you need to replace this with your CNAME:

server {
    listen 443;
    server_name <CNAME>;

...

[5]. Run certbot

> sudo certbot --nginx -d <CNAME>

If successful you will see a message like:

...
IMPORTANT NOTES:
 - Congratulations! Your certificate and chain have been saved at:
   /etc/letsencrypt/live/standalone.killbill.io/fullchain.pem
   Your key file has been saved at:
   /etc/letsencrypt/live/standalone.killbill.io/privkey.pem
   Your cert will expire on 2020-05-11. To obtain a new or tweaked
   version of this certificate in the future, simply run certbot again
   with the "certonly" option. To non-interactively renew *all* of
   your certificates, run "certbot renew"
 - If you like Certbot, please consider supporting our work by:

   Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
   Donating to EFF:                    https://eff.org/donate-le

[6]. Restart all services

# Start nginx
> service killbill nginx
# Start killbill
> service killbill stop
# Start kaui
> service kaui stop

Note: You can edit your security groups and remove the port 80, and also reduce the visibility for other ports by specifying a tighter range of incoming IPs.

The Let’s Encrypt certifcates are only valid 90 days and will therefore neeed to be renewed. certbot will create a cron entry under /etc/cron.d/certbot to make this process transparent.

Kill Bill

Kill Bill global properties are defined in /var/lib/killbill/config/killbill.properties. This is where you can change the MySQL credentials for instance. Take a look at our configuration guide for more details.

This is also where you can change the default Kill Bill admin credentials: specify org.killbill.security.shiroResourcePath=/var/lib/killbill/config/shiro.ini and create the shiro.ini file accordingly (see our RBAC guide for more details).

TroubleShooting Section

After launching the EC2 instance, the full stack should come up, with all services enabled and running, that is:

  • An nginx instance receiving traffic on port 443 and 8443

  • A instance of Kill Bill server listening on 127.0.0.1:8080 (and receiving external traffic through nginx on port 8443)

  • A instance of Kaui listening on 127.0.0.1:3000 (and receiving external traffic through nginx on port 443)

  • A local mysql server running on port 3306

In this section, we will provide some tips to verify the health of the system, and what to do when things are not working

SSH to EC2 Instances

From the EC2 dashboard, in the instance Description tab, you can copy the public DNS, called Public DNS (IPv4). Then, using the private key you specified when creating the instance:

# SSH as ubuntu user
> ssh -i  <LOCATION_KEY>/<KEY_NAME>.pem [email protected]<PUBLIC_DNS>
# Move to tomcat user
> sudo su - tomcat

Service Health

All services are started using System V init scripts, and so the status of the service can be retrieved:

  • Kill Bill server: service killbill status

  • KAUI server: service kaui status

  • Nginx server: service nginx status

Similarly one can start, stop the services using simalar command — e.g service kaui stop to stop KAUI.

In order to verify the health of the Kill Bill server instance, you can issue the following commands:

Log Files

Tomcat logs are under /var/lib/tomcat/logs/:

  • KAUI logs: /var/lib/tomcat/logs/kaui.out

  • Kill Bill server logs: /var/lib/tomcat/logs/catalina.out

Nginx logs can be found under /var/log/nginx/

  • Access logs: /var/log/nginx/access.log

  • Error logs: /var/log/nginx/error.log

System Diagnostics

In order to get some support, the first thing we would require is some information about your deployment. We have created a diagnostic command for that effect:

# Login as 'tomcat'
> sudo su - tomcat
#
# Assume a 'bob/lazar' tenant
# Assume some credentials 'admin/password'
#
> kpm  diagnostic \
  --killbill-credentials=admin password \
  --bundles-dir=/var/lib/killbill/bundles \
  --database-name=killbill \
  --database-credentials=root root \
  --killbill-api-credentials=bob lazar \
  --kaui-web-path=/var/lib/tomcat/webapps2 \
  --killbill-url=http://127.0.0.1:8080 \
  --database-host=127.0.0.1:3306

...
Diagnostic data exported under /tmp/killbill-diagnostics-20200213-23204-u93ah5/killbill-diagnostics-02-13-20.zip

Database

In order to access the database, one can use the following command mysql -u root -proot. There is one killbill and one kaui database created and used by the respective application

Nginx

The configuration files are located under /etc/nginx/ — e.g /etc/nginx/sites-enabled/killbill.conf

Upgrade steps

Note: you must switch to the tomcat user first in order to upgrade Kill Bill or Kaui (sudo su - tomcat).

The configuration file /var/lib/killbill/kpm.yml specifies the Kill Bill version (and its plugins) running on the instance. After updating this file with the new version(s), simply execute $KPM_INSTALL_KB_CMD, delete the cached directory /var/lib/tomcat/webapps/ROOT and restart the instance.

A similar process can be used for Kaui: update /var/lib/kaui/kpm.yml, run $KPM_INSTALL_KAUI_CMD, delete the cached directory /var/lib/tomcat/webapps2/ROOT and restart the instance.

Installation via CloudFormation

The Standalone AMIs are very convenient to start a full stack on ONE EC2 instance, but for production deployments, we suggest to use our CloudFormation tempate to start a fully redundant stack.

Overview of the Stack

Running Kill Bill on AWS using our official CloudFormation template is the easiest and fastest way to get started with a production cluster. It is also the only method of installation that is certified by the core developers for a Highly Available, horizontally scalable and production-ready installation.

With the click of a button, the template will install and configure:

  • Kill Bill and Kaui on a custom AMI optimized for AWS workloads (integrated with CloudWatch, SQS, SES, X-Ray and more)

  • Auto Scaling Groups, to automatically scale up and down the number of instances as needed (such as when batches of invoices are generated)

  • A load balancer, integrated with our internal healthchecks to promptly take out of rotation unhealthy instances

  • A RDS Aurora Cluster with automatic failover

The following diagram shows the various AWS entities that will be created by CloudFormation:

cf stack

The elastic load balancer will listen on the port 80 for routing traffic to our Kill Bill server instances, and on the port 9090 for accessing KAUI, our admin UI. Internally, both Kill Bill server instances, and KAUI server instances will listen on port 8080.

The CloudFormation template allows to specify different groups of subnets to isolate the Kill Bill server and KAUI server instances with the RDS instances. Typically one would specify at least 2 subnets, in different availability zones for each of those groups.

The CloudFormation template will also create individual security groups for the various components:

  • LB Security group: Opens ingress 9090 and 80, and everything for egress.

  • KB Security group: Opens ingress 8080, and everything for egress.

  • RDS Security group: Opens ingress 3306, and everything for egress.

Pre-requisites: The CloudFormation template will require thr following:

  • A valid VPC

  • A VPC Internet Gateway configured to access all the touside world

  • Valid subnets for the VPC as described above

Example: Given a VPC with a CIDR of 192.168.0.0/16

An example of a valid routing table for would be

DestinationTarget

192.168.0.0/16

local

0.0.0.0/0

igw-08bbaa2909129b953

Regarding the subnets, the following configuration would work:

  • Kill Bill server and KAUI server instances subnets: 192.168.64.0/18 (zone 1e) and 192.168.192.0/18 (zone 1b)

  • RDS subnets: 192.168.128.0/18 (zone 1e) and 192.168.0.0/18 (zone 1b)

CloudWatch Integration

Our AMIs come pre-configured with CloudWatch integration to allow for better diagnostics. Below is a screenshot of the metrics that come for free:

cloudwatch

In order to have business metrics, we also allow to install additional plugins suchs as our free Analytics plugin. This provides a subscription billing management solution as feature-rich as popular SaaS platforms, but that you can control. Below is a screenshot of such business metrics:

analytics

For installation support along the way, reach out to [email protected].

Configuration Options

The installation supports the following configuration options:

  • VpcId: the VPC to use for the installation. In your AWS Console, go to Services and search for VPC. Under Your VPCs, locate the VPC ID you would like to use or create a new one.

  • Subnets: the subnets to use for the KB and KAUi instances. They should be associated with at least two different availability zones. In the VPC Dashboard, go to Subnets and find two subnets in your VPC in two different availability zones. Alternatively, create new ones (use 10.0.0.0/24 and 10.0.1.0/24 as the IPv4 CIDR for instance).

  • RDSSubnets: the subnets to use for the RDS instance. The RDS instances require a subnet group with at least two different availability zones.

  • KeyName: name of an existing EC2 KeyPair to enable SSH access to the instances. You can create a new one by going to Key Pairs in your EC2 Dashboard.

  • HTTPLocation: IP address range allowed to access the load balancer (you can always use 0.0.0.0/0 initially and adjust access later on).

  • EnvType: environment purpose (test, prod, etc.). No difference in the stack being created but stack will send this variable to CloudWatch as a dimension.

  • InstanceType: the EC2 instance type to use for Kill Bill.

  • KillBillServerCapacity: the initial number of Kill Bill instances in the Auto Scaling group.

  • KauiServerCapacity: the initial number of Kaui instances in the Auto Scaling group. We recommend using the default value 2.

  • KBAdminPassword: the admin password that will be used for the default root user which has all the permissions. By default such password is set to password. Typically, one would use the root user to create additional roles (along with their permissions) to limit the scope of what specific applications or users can do. See our User Management Documentation.

  • DBClass: the database instance type to use for RDS.

  • DBName: database name for Kill Bill. We recommend using the default value killbill.

  • KauiDBName: database name for Kaui. We recommend using the default value kaui.

  • DBUser: database admin username

  • DBPassword: database admin password

  • EnableCloudWatchMetrics: whether to record Kill Bill metrics in CloudWatch. Strongly recommended for production. When enabled, a default monitoring dashboard will be created.

Setup Steps

  1. Start the installation process by going to AWS Marketplace: click Continue to Subscribe and populate the configuration options in the CloudFormation form.

  2. Launch the stack.

  3. Upon success, the Outputs tab will display the load balancer URL. Kill Bill is available on port 80 while Kaui on port 9090.

You can log-in to Kaui by going to http://<LOAD_BALANCER_URL>:9090 (make sure your IP address can access the load balancer, as defined by the parameter HTTPLocation, or add it to the security group as needed). Default credentials are: admin/password.

Take a look at our Getting Started guide for an introduction to Kaui.

TroubleShooting Section

Stack Creation

There are a couple of possible issues when starting the stack from CloudFormation (CFN) and so the goal of this section is to provide some tips debugging the issues, and knowledge about where to find various logs. Also keep in mind that starting the CFN stack will typically take in the order of 15-20', mostly because of the time it takes to setup the RDS cluster, so be patient…​

Let’s start with the CloudFormation console: The stack will have a status which will be CREATE_IN_PROGRESS for the duration of the initialization, and will then either transition to CREATE_COMPLETE or CREATE_FAILED. In case of CREATE_FAILED, try to locate from the Resources tab which resource fail to initialize properly.

Possible Issues

The main possible issues can be summarized as:

Issues with the template

If you think there is an issue with the CFN template itself, please report any issue to [email protected]

AWS Errors

Typical Issues are:

  • Insufficient IAM Permissions

  • Limit Exceeded

  • Security Group Does Not Exist in VPC

  • RDS Cluster failed to come up

  • …​

Make sure to check our Pre-requisites section to ensure you have setup a valid VPC with valid subnets. Fow AWS specific issues, please refer to the AWS troubleshooting documentation

Service Unavailable

We suggest to check the following:

  1. Is there any issues reported in the CFN logs

  2. Is the database up and running and accessible from the Kill Bill/Kaui ec2 instances?

  3. Is the database schema correctly installed?

  4. Is the Kill Bill/Kaui server correctly started and listening to the port 8080?

  5. Are Kill Bill/Kaui server accessible from the LB, respectively on port 80 and 9090?

  6. Are there any errors, stack traces in our logs

Practical Tips

SSH to EC2 Instances

In order to answer these questions, you will first need to be able to SSH to the EC2 instances:

From the EC2 dashboard, you can locate the instances by filtering on a prefix of the name of your stack, in my case my-stack, and as indicated below you will see the instances for Kill Bill server and KAUI. In the example below we see one of each:

ec2 instances

You can select one instance and then from the description tag, you will have access to:

  1. Public DNS

  2. The security group

ec2 description

You will need to first click on the security group link to open the inbound port 22 required for SSH, as shown below:

security group

Then, you can issue the SSH command, by copying the Public DNS from the description tab:

# SSH as ubuntu user
> ssh -i  <LOCATION_KEY>/<KEY_NAME>.pem [email protected]<PUBLIC_DNS>
# Move to tomcat user
> sudo su - tomcat

CFN LOGS

If there are any issue with CFN, it should be available from /var/log/cfn-init-cmd.log or /var/log/cfn-init.log

Other logs of interest may include:

/var/log/cfn-wire.log
/var/log/cloud-init-output.log
/var/log/awslogs.logs
/var/log/xray/xray.log

Kill Bill/KAUI Server Logs

The Kill Bill/KAUI server logs are located under /var/lib/tomcat/logs/, with the main 2 interesting logs being:

  • killbill.out: All Kill Bill server logs, configured as INFO by default

  • kaui.out: All KAUI server logs, configured as INFO by default

  • localhost_access_log…​: Access requests to the servers

The configuration of the logging (log rotation, log level, …​) can be found in /var/lib/killbill/config/logback.xml

If you update the logback.xml (or any configuration file) you will need to restart the service. In order to restart the service, you can run as root the following command:

# Restart  killbill server instance
> service killbill restart
# Restart  kaui server instance
> service kaui restart

Access to the Database

From any Kill Bill EC2 instance, it is possible to access the RDS database. On each node, there is mysql client installed allowing to access the database. The database hostname can be obtained from the CFN Resources screen, or one can also extract this information from the killbill.propertes file:

> grep 'org.killbill.dao' /var/lib/killbill/config/killbill.properties
org.killbill.dao.password=killbill
org.killbill.dao.url=jdbc:mysql:aurora://mystack-test-rdscluster-1qwiqitatcb9m.cluster-cah16olm8gkg.us-east-1.rds.amazonaws.com:3306/killbill
org.killbill.dao.user=killbill

Based on such info, the following command would allow to get a mysql prompt:

> mysql -h mystack-test-rdscluster-1qwiqitatcb9m.cluster-cah16olm8gkg.us-east-1.rds.amazonaws.com -u killbill -pkillbill killbill
> show tables
> ...

Sevice Health

Since both Kill Bill/KAUI server listen on port 8080, one can easily check if the service is running by issuing the following command:

telnet 127.0.0.1 8080
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.

For the Kill Bill server specifically some useful commands are:

# Healthcheck
> curl http://127.0.0.1:8080/1.0/healthcheck
# Check which Kill Bill & plugin versions
> curl -u admin:<KBAdminPassword> http://127.0.0.1:8080/1.0/kb/nodesInfo | jq
[
  {
    "nodeName": "ip-192-168-65-236.ec2.internal",
    "bootTime": "2020-02-02T21:26:44.000Z",
    "lastUpdatedDate": "2020-02-02T21:26:44.000Z",
    "kbVersion": "0.22.1",
    "apiVersion": "0.53.17",
    "pluginApiVersion": "0.26.3",
    "commonVersion": "0.23.7",
    "platformVersion": "0.39.12",
    "pluginsInfo": [
      {
        "bundleSymbolicName": "org.kill-bill.billing.killbill-platform-osgi-bundles-kpm",
        "pluginKey": null,
        "pluginName": "org.kill-bill.billing.killbill-platform-osgi-bundles-kpm",
        "version": null,
        "state": "RUNNING",
        "isSelectedForStart": true,
        "services": []
      },
      {
        "bundleSymbolicName": "org.kill-bill.billing.killbill-platform-osgi-bundles-logger",
        "pluginKey": null,
        "pluginName": "org.kill-bill.billing.killbill-platform-osgi-bundles-logger",
        "version": null,
        "state": "RUNNING",
        "isSelectedForStart": true,
        "services": []
      }
    ]
  }
]

System Diagnostics

In order to get some support, the first thing we would require is some information about your deployment. We have created a diagnostic command that can be run on the Kill Bill server nodes and the KAUI nodes.

In order to get information about your Kill Bill server installation, the following command can be used:

# Login as 'tomcat'
> sudo su - tomcat
#
# Assume a 'bob/lazar' tenant
# Assume some credentials 'admin/password'
# Details about DB host can be extracted from '/var/lib/killbill/config/killbill.properties'
#
> kpm  diagnostic \
  --killbill-credentials=admin password \
  --bundles-dir=/var/lib/killbill/bundles \
  --database-name=killbill \
  --database-credentials=killbill killbill \
  --killbill-api-credentials=bob lazar \
  --killbill-web-path=/var/lib/tomcat/webapps \
  --database-host=my-stack-rdscluster-1uvr93sm7pzp.cluster-cah16olm8gkg.us-east-1.rds.amazonaws.com

...
Diagnostic data exported under /tmp/killbill-diagnostics-20200212-26849-c0rrz3/killbill-diagnostics-02-12-20.zip

Note that there is also a --account-export=<account_id> flag to export the data associated with a specific Kill Bill account_id.

In order to get information about your Kaui server installation, the following command can be used:

# Login as 'tomcat'
> sudo su - tomcat
#
# Assume a 'bob/lazar' tenant
# Assume some credentials 'admin/password'
# Details about DB host and killbill-url can be extracted from '/var/lib/tomcat/bin/setenv2.sh'
#
kpm  diagnostic \
  --killbill-credentials=admin password \
  --bundles-dir=/var/lib/killbill/bundles \
  --database-name=killbill \
  --database-credentials=killbill killbill \
  --killbill-api-credentials=bob lazar \
  --kaui-web-path=/var/lib/tomcat/webapps \
  --killbill-url=http://sbrossie-LB-1LJYJ1QHYSWQX-650823949.us-east-1.elb.amazonaws.com:80 \
  --database-host=sbrossier-rdscluster-1uvr93sm7pzp.cluster-cah16olm8gkg.us-east-1.rds.amazonaws.com

Upgrade Steps

Newer AMIs

The Kill Bill core team will provide new AMIs whenever necessary.

Because the CloudFormation from AWS Marketplace will always reflect the latest AMI ids, you can simply update the stack with the latest CloudFormation template and the instances in the AutoScaling groups will be updated automatically. We strongly recommend to always test the upgrade in a test environment first.

We recommend to rely on the CloudFormation ChangeSet functionality to get a sense of what would be updated if the change was submitted. For more information about the CloudFormation ChangeSet functionality see this documentation. Below is a summary of the steps:

[1]. Update your CloudFormation template with the new Kill Bill and/or KAUI AMIs

[2]. Create a new ChangeSet

As a pre-requisite, make sure you have the capabilities to perform the operation, and then proceed with the change set:

create change set

If you do have the permissions, you will be prompted with the following message, that you will need to acknowledge:

change set capabilities

[3]. Upload your new template

create change set template

Go through the steps, accepting the defaults

[4]. Review the CloudFormation changes

create change set diff

If those seem to match your template diff, then proceed with the change.

[5]. Wait for the new stack to be up

After CloudFormation change is done, you will see the STATUS or your stack transitions back to CREATE_COMPLETE.

create change set success

However, the old instances may not have yet completed the shutdown sequence and so effectively the change is not really complete. You should really check your EC2 Dashboard and verify the state of the instances (old and new). For example in the screenshot below we can see that the old KAUI instance got terminated and the new one is running, and so at this point the upgrade has completed.

kaui terminated

Default configuration

Either installation method comes with a default configuration to get you started.

A few plugins are also pre-configured, but not installed: all you need to do is head to the Kaui KPM page and select the plugin(s) of your choice to install.

Invoice templates

Kill Bill invoices can be rendered as HTML using our render HTML invoice API. This can be useful for instance to expose the invoices directly to your customer on the billing section of your website.

The default template looks as such:

invoice html

The text can be customized and translated. To do so, create file InvoiceTranslation_en_US.properties with the following content (adjust the values on the right side of the = sign as needed):

companyName=Acme Corporation
companyAddress=57 Academy Drive
companyCityProvincePostalCode=Oak Creek, WI 53154
companyCountry=US
invoiceTitle=Invoice
invoiceDate=Invoice Date:
invoiceAmount=Total:
invoiceAmountPaid=Amount Paid:
invoiceBalance=Balance:
invoiceItemServicePeriod=Service Period
invoiceItemDescription=Plan
invoiceItemAmount=Amount

and upload it to Kaui by going to your admin tenant page (InvoiceTranslation) tab:

invoice html config

Additional languages can be uploaded for each locale (e.g. specify fr_FR for French).

More details are available in our Internationalization userguide, including how to fully customize the template.

Email notifications

SMTP configuration

The plugin needs to be configured with an SMTP server to be able to send emails. The easiest to set it up on AWS is with SES.

Once you have obtained your credentials, update the plugin configuration:

email notifications config

Templates

The plugin comes with a preconfigured set of email templates.

For instance, this is the email which will be sent when an invoice is generated:

invoice email

This is what the user will receive when a subscription is cancelled:

cancellation email

The default set of translation strings are:

upcomingInvoiceAdditionalMessage=Here's a preview of your upcoming invoice
upcomingInvoiceSubject=Your upcoming invoice
invoiceCreationAdditionalMessage=Thank you for your prompt payment!
invoiceCreationSubject=Your recent invoice
successfulPaymentAdditionalMessage=Thank you for your recent payment!
successfulPaymentSubject=Your recent payment
failedPaymentAdditionalMessage=We were not able to process your payment!
failedPaymentSubject=Your recent payment
paymentRefundAdditionalMessage=Your refund has been processed!
paymentRefundSubject=Your recent payment
companyName=Acme Corporation
companyAddress=57 Academy Drive
companyCityProvincePostalCode=Oak Creek, WI 53154
companyCountry=US
invoicePrefix=INV#
invoiceTitle=Invoice
invoiceDate=Invoice Date:
invoiceAmount=Total:
invoiceAmountPaid=Amount Paid:
invoiceBalance=Balance:
invoiceItemServicePeriod=Service Period
invoiceItemDescription=Plan
invoiceItemAmount=Amount
paymentTitle=Payment
paymentDate=Payment Date:
paymentAmount=Total:
subscriptionCancellationRequestedAdditionalMessage=The following subscription will be cancelled
subscriptionCancellationRequestedSubject=Your subscription will be cancelled
subscriptionCancellationEffectiveAdditionalMessage=The following subscription has been cancelled
subscriptionCancellationEffectiveSubject=Your subscription has been cancelled
subscriptionTitle=Subscription
subscriptionEndDate=End Date:
susbscriptionPlan=Plan:

More details on how to update these and update the HTML templates are available in the plugin documentation.

Analytics plugin

The plugin comes with a few pre-configured reports:

  • Subscriptions creation: count the number of subscriptions being created per day (effective on that day, i.e. pending subscriptions are ignored). Refreshed every hour.

  • Effective cancellations: count the number of subscriptions being canceled per day (only effective cancellations are taken into account: end of term cancellations are ignored for instance). Refreshed every hour.

  • Overdue accounts: count the number of overdue accounts per day (defined as having a negative balance, i.e. owing money). Refreshed once a day at 6am GMT.

Custom reports can be added by following our Analytics guide.

analytics reports