Structuring Events in JavaScript

What you are doing seems pretty much the standard way to do this sort of thing with Javascript and jQuery .

A few pointers:

Often, you wrap functions with other anonymous functions, for example:

$("#dnsTitle a.save").click(function() {
    zPanel.loader.showLoader();
});

Could likely become:

$("#dnsTitle a.save").click(zPanel.loader.showLoader)

Speaking of which, every time you have an anonymous function that handles considerable amount of code, you should consider extracting it to a named method.

Is it generally a good idea or not to put all my Events into 1 area like that and then have the fire of other functions instead of cluttering there callback area with logic code?

Yes, it is. Generally your event listeners when writing this sort of code 'control' the flow of events. That area (like in your code) is in charge of negotiating between your data and user/presentation, letting the logic layer know when the change happened. It is generally cleaner to register all such handlers in a specific place.

General tips:

• Use semi-colons. In JS, although they are optional, you should use them to avoid syntax errors, especially when minifying.

• To modularize your code, wrap them in a closure. Consider it your "sandbox" for your code.

As for the rest, it's in the comments

//enclosing it in a closure so we won't spill to the global scope
//a general tip I keep is that 
//if this module performs something only it should do, then keep it in the scope (private)
//everything that others can use (public) gets exposed via the namespace
(function (window, document, $, undefined) {

    //we cache a few useful values, like jQuery wrapped window and document
  var $window = $(window),
    $document = $(document),

    //here's an example of exposing. we expose this object as dnsRecords
    //to the global scope. Since assignment operations "spill left"
    //the same object gets assigned to the local dnsRecord
    //we do this since every access to a property (something dot something)
    //is an overhead. also, assigning to a variable is shorter anyway.
    dnsRecords = window.dnsRecords = {
      unsavedChanges: false
      addRow: function (record) {},
      save: function () {},
      undoRow: function (row) {},
      deleteRow: function (row) {
        dnsRecords.unsavedChanges = true;
      }
    };

  //here, we declare your init methods
  //like stated above, since only this module uses init, it's kept in the scope
  //rather than it being exposed
  function bindDom() {

    //we then use the cached values
    $window.on('beforeunload', dnsRecords.promptBeforeClose);

    //did you know that the on method returns the object it operated on
    //which means it returns $document, which also means we can chain on
    //also, I suggest you delegate to the nearest available parent
    //for shorter delegation. In this code you have, the event needs
    //to "bubble" to the document root in order for handlers to execute
    //which is also an overhead, and the same reason live was deprecated

    $document
      .on('keypress', '#typeMX div.hostName > input', function () {
        $document.off('keypress', '#typeMX div.hostName > input');
      })
      .on("keydown", "#dnsRecords input", function () {

      })
      .on("click", ".delete", function (e) {
        dnsRecords.deleteRow($(this));
        e.preventDefault();
      })
      .on("keydown", "div.dnsRecord input[type='text']", function () {

      });

    $("#dnsRecords div.add > .btn").click(function (e) {
      e.preventDefault();
    });

    $("button.undo").on("click", function () {
      dnsRecords.undoRow($(this))
    });

    $("#dnsTitle a.save").click(function () {
      zPanel.loader.showLoader();
    });

    $("#dnsTitle a.undo").click(function () {});

    $("form").submit(function () {});
  }

  //you can declare other functions here as well to split operations
  function someOtherInitStuff(){
    ...
  }

  //I notice your init function is called on documentReady
  //why not merge it in the module, and make that function your init
  $(function () {

    //call stuff you want to init
    bindDom();
    someOtherInitStuff();
  });

}(this, document, jQuery));

//out here, your exposed methods are like:
dnsRecords.addRow();
dnsRecords.save();