This message opened by ... Anonymous

We had a prospective customer recently come to us with an interesting request with regard to the privacy of their email recipients. They wanted the actions of their email recipients to be anonymized in such a way that in no way would it be possible for anyone to determine which specific email addresses opened, clicked, unsubscribed, or experienced a bounce in a given email.

The prospective customer had a real concern for the privacy of their recipients but still desired the aggregate reporting metrics that make things like measuring the effectiveness of a group of emails possible. Total clicks? Great. Who clicked on which link? Gone.

We were happy to custom-develop this feature for the customer. And since we developed the software to do it for them, we can make it available to you — upon request.

The feature ensures that the specific email addresses are purged from the database and removed from the SMTP logs after receipt, ensuring they cannot be retrieved or compromised by anyone. The total actions for each transactional group are still aggregated and made available via reporting. 
 
This feature is a good example of how we're willing to go lengths to fulfill the needs of a customer who knows what they want. While this may seem obscure, if you'd like this feature added to your account, or have another custom feature in mind, please don't hesitate to ask.

Sending Transactional Messages from a Ruby Application

Do you need to send transactional emails from a Ruby application? Do you need open tracking, DKIM signing and easy to read reports? If so, then JangoSMTP is your solution.

This example demonstrates how to send messages using JangoSMTP from within a Ruby application. You will need the Mail gem, which can be installed with the command gem install mail.

After the mail gem is installed, download the source code for this example and insert your own JangoSMTP username/password/etc. It's as easy as that!

require 'mail'

Mail.defaults do
  delivery_method :smtp, { :address   => "relay.jangosmtp.net",
                           :port      => 25,
                           :domain    => "YourDomain.com",
                           :user_name => "Your Username",
                           :password  => "Your Password",
                           :authentication => 'plain',
                           :enable_starttls_auto => true }
end

# Set up your email
# The from address must be stored in your list of from addresses
# see Settings > Advanced > From Addresses
mail = Mail.deliver do
  to 'To@EmailAddress.com'
  from 'From Name <FromAddress@YourDomain.com>'
  subject 'This is the subject!'
  text_part do
    body 'This plain text email was sent by Ruby!'
  end
  html_part do
    content_type 'text/html; charset=UTF-8'
    body '<b>This HTML email was sent by Ruby!</b>'
  end
end

Integrating JangoSMTP with Java

Since Oracle provides the JavaMail package for sending emails in Java, it's easy to integrate JangoSMTP into your current Java software.

First, you need to obtain the JavaMail library. If you're using the enterprise edition of Java, then you probably already have JavaMail installed. Otherwise, you will need to unzip the contents and add them to your buildpath in Eclipse, or your classpath in Windows. To add the package to your buildpath, click Project > Properties > Libraries > Add External JARs.

Then you can use JavaMail to connect to the JangoSMTP server and send a message. You should connect to relay.jangosmtp.net using your JangoSMTP credentials. We've already built a simple example that will connect to JangoSMTP to send a message.

Properties props = new Properties();
props.put("mail.transport.protocol", "smtp");
props.put("mail.smtp.host", "relay.jangosmtp.net");
props.put("mail.smtp.port", 25);
props.put("mail.smtp.auth", "true");
 
// set up a new authenticator
Authenticator Authorization = new SMTPAuthenticator();
Session JangoSMTPSession = 
             Session.getDefaultInstance(props, Authorization);
Transport transport = JangoSMTPSession.getTransport();
 
// this object will hold the details of the email
MimeMessage EmailMessage = new MimeMessage(JangoSMTPSession);
 
// store the plain text and HTML portions of our email
Multipart MultipartContent = new MimeMultipart("alternative");
 
// first set the plain text message
BodyPart part1 = new MimeBodyPart();
part1.setText(PlainTextMessage);
MultipartContent.addBodyPart(part1);
 
// then set the HTML message
BodyPart part2 = new MimeBodyPart();
part2.setContent(HTMLMessage, "text/html");
MultipartContent.addBodyPart(part2); 
 
EmailMessage.setContent(MultipartContent);
        
// Set the From Address.
// Must be a sender that is saved in your from-addresses.
EmailMessage.setFrom(new InternetAddress(FromAddress));
        
// Set the subject
EmailMessage.setSubject(Subject);
        
// set the to-address
EmailMessage.addRecipient(Message.RecipientType.TO,
                                new InternetAddress(ToAddress));
 
// Connect, Send the Message, and Close the Connection
transport.connect();
transport.sendMessage(EmailMessage, 
          EmailMessage.getRecipients(Message.RecipientType.TO));
transport.close();

With the authentication code that is in the example file, this code will allow you to construct and send a transactional email using JangoSMTP. This email will contain all the tracking and other features set up in the settings section of the JangoSMTP site.