basic scaffolding for sending a one-time follow up email to users.

src/metabase/email/follow_up_email.mustache

+{{> metabase/email/_header }}
+  <div style="padding: 2em 4em; border: 1px solid #dddddd; border-radius: 2px; background-color: white; box-shadow: 0 1px 2px rgba(0, 0, 0, .08); text-align: center;">
+    <p>
+      {{callToAction}}
+    </p>
+    <p>
+      <a href="{{link}}">{{buttonText}}</a>
+    </p>
+  </div>
+{{> metabase/email/_footer }}

src/metabase/email/messages.clj

@@ -88,6 +88,34 @@
       :message-type :html
       :message      message-body)))
 
+(defn send-follow-up-email
+  "Format and Send an email to the system admin following up on the installation."
+  [email type]
+  {:pre [(string? email)
+         (u/is-email? email)
+         (contains? #{"active" "inactive"} type)]}
+  (let [subject       (if (= "inactive" type)
+                        "[Metabase] Where have you been?"
+                        "[Metabase] What else can we do for you?")
+        data-quote    (quotation/random-quote)
+        context       (merge {:emailType       "notification"
+                              :logoHeader      true
+                              :quotation       (:quote data-quote)
+                              :quotationAuthor (:author data-quote)}
+                             (if (= "inactive" type)
+                               {:callToAction "We haven’t seen you much! Would you mind taking a minute to tell us what we could do better?"
+                                :buttonText   "Button"
+                                :link         "http://www.metabase.com/feedback/this-thing-sucks"}
+                               {:callToAction "Hey there! We hope you’ve been enjoying Metabase. Do you mind taking a minute to tell us how it’s going?"
+                                :buttonText   "Button"
+                                :link         "http://www.metabase.com/feedback/best-analytics-evar"}))
+        message-body  (stencil/render-file "metabase/email/follow_up_email" context)]
+    (email/send-message
+      :subject      subject
+      :recipients   [email]
+      :message-type :html
+      :message      message-body)))
+
 ;; HACK: temporary workaround to postal requiring a file as the attachment
 (defn- write-byte-array-to-temp-file
   [^bytes img-bytes]

src/metabase/task/follow_up_emails.clj

+(ns metabase.task.follow-up-emails
+  "Tasks which follow up with Metabase users."
+  (:require [clj-time.coerce :as c]
+            [clj-time.core :as t]
+            [clojure.tools.logging :as log]
+            (clojurewerkz.quartzite [jobs :as jobs]
+                                    [triggers :as triggers])
+            [clojurewerkz.quartzite.schedule.cron :as cron]
+            [korma.core :as k]
+            [metabase.db :as db]
+            [metabase.email :as email]
+            [metabase.email.messages :as messages]
+            [metabase.models.activity :as activity]
+            [metabase.models.setting :as setting]
+            [metabase.models.user :as user]
+            [metabase.models.view-log :as view-log]
+            [metabase.task :as task]))
+
+
+(declare send-follow-up-email!)
+
+(def ^:private ^:const follow-up-emails-job-key     "metabase.task.follow-up-emails.job")
+(def ^:private ^:const follow-up-emails-trigger-key "metabase.task.follow-up-emails.trigger")
+
+(defonce ^:private follow-up-emails-job (atom nil))
+(defonce ^:private follow-up-emails-trigger (atom nil))
+
+(setting/defsetting follow-up-email-sent "have we sent a follow up email to the instance admin?" false :internal true)
+
+;; triggers the sending of all pulses which are scheduled to run in the current hour
+(jobs/defjob FollowUpEmail
+             [ctx]
+             ;; 1. if we've already sent the follow-up email then we are done
+             (when-not (= "true" (follow-up-email-sent))
+               ;; figure out when we consider the instance created (join date of oldest user)
+               (when-let [instance-created (-> (k/select user/User
+                                                 (k/fields :date_joined)
+                                                 (k/order :date_joined :ASC)
+                                                 (k/limit 1))
+                                               first
+                                               :date_joined
+                                               .getTime)]
+                 ;; 2. we need to be 2+ weeks (14 days) from creation to send the follow up
+                 (when (< (* 14 24 60 60 1000)
+                          (- (System/currentTimeMillis) instance-created))
+                   ;; 3. we need  access to email AND the instance must be opted into anonymous tracking
+                   (when (and (email/email-configured?)
+                              (let [tracking? (setting/get :anon-tracking-enabled)]
+                                (or (nil? tracking?) (= "true" tracking?))))
+                     (send-follow-up-email!))))))
+
+(defn task-init
+  "Automatically called during startup; start the job for sending pulses."
+  []
+  ;; build our job
+  (reset! follow-up-emails-job (jobs/build
+                                 (jobs/of-type FollowUpEmail)
+                                 (jobs/with-identity (jobs/key follow-up-emails-job-key))))
+  ;; build our trigger
+  (reset! follow-up-emails-trigger (triggers/build
+                                     (triggers/with-identity (triggers/key follow-up-emails-trigger-key))
+                                     (triggers/start-now)
+                                     (triggers/with-schedule
+                                       ;; run once a day
+                                       (cron/cron-schedule "0 0 12 * * ? *"))))
+  ;; submit ourselves to the scheduler
+  (task/schedule-task! @follow-up-emails-job @follow-up-emails-trigger))
+
+
+(defn- send-follow-up-email!
+  "Send an email to the instance admin following up on their experience with Metabase thus far."
+  []
+  (try
+    ;; grab the oldest admins email address, that's who we'll send to
+    (when-let [admin (db/sel :one user/User :is_superuser true (k/order :date_joined))]
+      ;; check for activity and use that to determine which email we'll send
+      ;; inactive = no users created, no activity created, no dash/card views (past 7 days)
+      (let [last-user      (c/from-sql-time (db/sel :one :field [user/User :date_joined] (k/order :date_joined :DESC) (k/limit 1)))
+            last-activity  (c/from-sql-time (db/sel :one :field [activity/Activity :timestamp] (k/order :timestamp :DESC) (k/limit 1)))
+            last-view      (c/from-sql-time (db/sel :one :field [view-log/ViewLog :timestamp] (k/order :timestamp :DESC) (k/limit 1)))
+            seven-days-ago (t/minus (t/now) (t/days 7))
+            message-type   (if (and (t/before? last-user seven-days-ago)
+                                    (t/before? last-activity seven-days-ago)
+                                    (t/before? last-view seven-days-ago))
+                             "inactive"
+                             "active")]
+        (messages/send-follow-up-email (:email admin) message-type)))
+    (catch Throwable t
+      (log/error "Problem sending follow-up email" t))
+    (finally
+      (setting/set :follow-up-email-sent "true"))))
+